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.awt.FontFormatException;
30 import java.io.BufferedReader;
31 import java.io.File;
32 import java.io.FileInputStream;
33 import java.io.FilenameFilter;
34 import java.io.IOException;
35 import java.io.InputStreamReader;
36 import java.security.AccessController;
37 import java.security.PrivilegedAction;
38 import java.util.ArrayList;
39 import java.util.HashMap;
40 import java.util.HashSet;
41 import java.util.Hashtable;
42 import java.util.List;
43 import java.util.Locale;
44 import java.util.Map;
45 import java.util.NoSuchElementException;
46 import java.util.StringTokenizer;
47 import java.util.TreeMap;
48 import java.util.Vector;
49 import java.util.concurrent.ConcurrentHashMap;
50
51 import javax.swing.plaf.FontUIResource;
52
53 import sun.awt.FontConfiguration;
54 import sun.awt.SunToolkit;
55 import sun.awt.util.ThreadGroupUtils;
56 import sun.java2d.FontSupport;
57 import sun.util.logging.PlatformLogger;
58
59 /**
60 * The base implementation of the {@link FontManager} interface. It implements
61 * the platform independent, shared parts of OpenJDK's FontManager
62 * implementations. The platform specific parts are declared as abstract
63 * methods that have to be implemented by specific implementations.
64 */
65 public abstract class SunFontManager implements FontSupport, FontManagerForSGE {
66
67 private static class TTFilter implements FilenameFilter {
68 public boolean accept(File dir,String name) {
69 /* all conveniently have the same suffix length */
70 int offset = name.length()-4;
71 if (offset <= 0) { /* must be at least A.ttf */
72 return false;
73 } else {
74 return(name.startsWith(".ttf", offset) ||
75 name.startsWith(".TTF", offset) ||
76 name.startsWith(".ttc", offset) ||
77 name.startsWith(".TTC", offset) ||
78 name.startsWith(".otf", offset) ||
79 name.startsWith(".OTF", offset));
80 }
81 }
82 }
83
84 private static class T1Filter implements FilenameFilter {
85 public boolean accept(File dir,String name) {
86 if (noType1Font) {
87 return false;
88 }
89 /* all conveniently have the same suffix length */
90 int offset = name.length()-4;
91 if (offset <= 0) { /* must be at least A.pfa */
92 return false;
93 } else {
94 return(name.startsWith(".pfa", offset) ||
95 name.startsWith(".pfb", offset) ||
96 name.startsWith(".PFA", offset) ||
97 name.startsWith(".PFB", offset));
98 }
99 }
100 }
101
102 private static class TTorT1Filter implements FilenameFilter {
103 public boolean accept(File dir, String name) {
104
105 /* all conveniently have the same suffix length */
106 int offset = name.length()-4;
107 if (offset <= 0) { /* must be at least A.ttf or A.pfa */
108 return false;
109 } else {
110 boolean isTT =
111 name.startsWith(".ttf", offset) ||
112 name.startsWith(".TTF", offset) ||
113 name.startsWith(".ttc", offset) ||
114 name.startsWith(".TTC", offset) ||
115 name.startsWith(".otf", offset) ||
116 name.startsWith(".OTF", offset);
117 if (isTT) {
118 return true;
119 } else if (noType1Font) {
120 return false;
121 } else {
122 return(name.startsWith(".pfa", offset) ||
123 name.startsWith(".pfb", offset) ||
124 name.startsWith(".PFA", offset) ||
125 name.startsWith(".PFB", offset));
126 }
127 }
128 }
129 }
130
131 private static Font2DHandle FONT_HANDLE_NULL = new Font2DHandle(null);
132
133 public static final int FONTFORMAT_NONE = -1;
134 public static final int FONTFORMAT_TRUETYPE = 0;
135 public static final int FONTFORMAT_TYPE1 = 1;
136 public static final int FONTFORMAT_TTC = 2;
137 public static final int FONTFORMAT_COMPOSITE = 3;
138 public static final int FONTFORMAT_NATIVE = 4;
139
140 /* Pool of 20 font file channels chosen because some UTF-8 locale
141 * composite fonts can use up to 16 platform fonts (including the
142 * Lucida fall back). This should prevent channel thrashing when
143 * dealing with one of these fonts.
144 * The pool array stores the fonts, rather than directly referencing
145 * the channels, as the font needs to do the open/close work.
146 */
147 // MACOSX begin -- need to access these in subclass
148 protected static final int CHANNELPOOLSIZE = 20;
149 protected FileFont[] fontFileCache = new FileFont[CHANNELPOOLSIZE];
150 // MACOSX end
151 private int lastPoolIndex = 0;
152
153 /* Need to implement a simple linked list scheme for fast
154 * traversal and lookup.
155 * Also want to "fast path" dialog so there's minimal overhead.
156 */
157 /* There are at exactly 20 composite fonts: 5 faces (but some are not
158 * usually different), in 4 styles. The array may be auto-expanded
159 * later if more are needed, eg for user-defined composites or locale
160 * variants.
161 */
162 private int maxCompFont = 0;
163 private CompositeFont [] compFonts = new CompositeFont[20];
164 private ConcurrentHashMap<String, CompositeFont>
165 compositeFonts = new ConcurrentHashMap<>();
166 private ConcurrentHashMap<String, PhysicalFont>
167 physicalFonts = new ConcurrentHashMap<>();
168 private ConcurrentHashMap<String, PhysicalFont>
169 registeredFonts = new ConcurrentHashMap<>();
170
171 /* given a full name find the Font. Remind: there's duplication
172 * here in that this contains the content of compositeFonts +
173 * physicalFonts.
174 */
175 // MACOSX begin -- need to access this in subclass
176 protected ConcurrentHashMap<String, Font2D>
177 fullNameToFont = new ConcurrentHashMap<>();
178 // MACOSX end
179
180 /* TrueType fonts have localised names. Support searching all
181 * of these before giving up on a name.
182 */
183 private HashMap<String, TrueTypeFont> localeFullNamesToFont;
184
185 private PhysicalFont defaultPhysicalFont;
186
187 static boolean longAddresses;
188 private boolean loaded1dot0Fonts = false;
189 boolean loadedAllFonts = false;
190 boolean loadedAllFontFiles = false;
191 String[] jreOtherFontFiles;
192 boolean noOtherJREFontFiles = false; // initial assumption.
193
194 public static String jreLibDirName;
195 public static String jreFontDirName;
196 private static HashSet<String> missingFontFiles = null;
197 private String defaultFontName;
198 private String defaultFontFileName;
199 protected HashSet<String> registeredFontFiles = new HashSet<>();
200
201 private ArrayList<String> badFonts;
202 /* fontPath is the location of all fonts on the system, excluding the
203 * JRE's own font directory but including any path specified using the
204 * sun.java2d.fontpath property. Together with that property, it is
205 * initialised by the getPlatformFontPath() method
206 * This call must be followed by a call to registerFontDirs(fontPath)
207 * once any extra debugging path has been appended.
208 */
209 protected String fontPath;
210 private FontConfiguration fontConfig;
211 /* discoveredAllFonts is set to true when all fonts on the font path are
212 * discovered. This usually also implies opening, validating and
213 * registering, but an implementation may be optimized to avold this.
214 * So see also "loadedAllFontFiles"
215 */
216 private boolean discoveredAllFonts = false;
217
218 /* No need to keep consing up new instances - reuse a singleton.
219 * The trade-off is that these objects don't get GC'd.
220 */
221 private static final FilenameFilter ttFilter = new TTFilter();
222 private static final FilenameFilter t1Filter = new T1Filter();
223
224 private Font[] allFonts;
225 private String[] allFamilies; // cache for default locale only
226 private Locale lastDefaultLocale;
227
228 public static boolean noType1Font;
229
230 /* Used to indicate required return type from toArray(..); */
231 private static String[] STR_ARRAY = new String[0];
232
233 /**
234 * Deprecated, unsupported hack - actually invokes a bug!
235 * Left in for a customer, don't remove.
236 */
237 private boolean usePlatformFontMetrics = false;
238
239 /**
240 * Returns the global SunFontManager instance. This is similar to
241 * {@link FontManagerFactory#getInstance()} but it returns a
242 * SunFontManager instance instead. This is only used in internal classes
243 * where we can safely assume that a SunFontManager is to be used.
244 *
245 * @return the global SunFontManager instance
246 */
247 public static SunFontManager getInstance() {
248 FontManager fm = FontManagerFactory.getInstance();
249 return (SunFontManager) fm;
250 }
251
252 public FilenameFilter getTrueTypeFilter() {
253 return ttFilter;
254 }
255
256 public FilenameFilter getType1Filter() {
257 return t1Filter;
258 }
259
260 /* After we reach MAXSOFTREFCNT, use weak refs for created fonts.
261 * This means that a small number of created fonts as used in a UI app
262 * will not be eagerly collected, but an app that create many will
263 * have them collected more frequently to reclaim storage.
264 */
265 private static int maxSoftRefCnt = 10;
266
267 static {
268 AccessController.doPrivileged(new PrivilegedAction<Void>() {
269 public Void run() {
270 FontManagerNativeLibrary.load();
271
272 // JNI throws an exception if a class/method/field is not found,
273 // so there's no need to do anything explicit here.
274 initIDs();
275
276 switch (StrikeCache.nativeAddressSize) {
277 case 8: longAddresses = true; break;
278 case 4: longAddresses = false; break;
279 default: throw new RuntimeException("Unexpected address size");
280 }
281
282 noType1Font = "true".equals(System.getProperty("sun.java2d.noType1Font"));
283 jreLibDirName = System.getProperty("java.home","") + File.separator + "lib";
284 jreFontDirName = jreLibDirName + File.separator + "fonts";
285
286 maxSoftRefCnt = Integer.getInteger("sun.java2d.font.maxSoftRefs", 10);
287 return null;
288 }
289 });
290 }
291
292 /**
293 * If the module image layout changes the location of JDK fonts,
294 * this will be updated to reflect that.
295 */
296 public static final String getJDKFontDir() {
297 return jreFontDirName;
298 }
299
300 public TrueTypeFont getEUDCFont() {
301 // Overridden in Windows.
302 return null;
303 }
304
305 /* Initialise ptrs used by JNI methods */
306 private static native void initIDs();
307
308 protected SunFontManager() {
309 AccessController.doPrivileged(new PrivilegedAction<Void>() {
310 public Void run() {
311 File badFontFile =
312 new File(jreFontDirName + File.separator + "badfonts.txt");
313 if (badFontFile.exists()) {
314 badFonts = new ArrayList<>();
315 try (FileInputStream fis = new FileInputStream(badFontFile);
316 BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
317 while (true) {
318 String name = br.readLine();
319 if (name == null) {
320 break;
321 } else {
322 if (FontUtilities.debugFonts()) {
323 FontUtilities.logWarning("read bad font: " + name);
324 }
325 badFonts.add(name);
326 }
327 }
328 } catch (IOException e) {
329 }
330 }
331
332 /* Here we get the fonts in jre/lib/fonts and register
333 * them so they are always available and preferred over
334 * other fonts. This needs to be registered before the
335 * composite fonts as otherwise some native font that
336 * corresponds may be found as we don't have a way to
337 * handle two fonts of the same name, so the JRE one
338 * must be the first one registered. Pass "true" to
339 * registerFonts method as on-screen these JRE fonts
340 * always go through the JDK rasteriser.
341 */
342 if (FontUtilities.isLinux) {
343 /* Linux font configuration uses these fonts */
344 registerFontDir(jreFontDirName);
345 }
346 registerFontsInDir(jreFontDirName, true, Font2D.JRE_RANK,
347 true, false);
348
349 /* Create the font configuration and get any font path
350 * that might be specified.
351 */
352 fontConfig = createFontConfiguration();
353
354 String[] fontInfo = getDefaultPlatformFont();
355 defaultFontName = fontInfo[0];
356 if (defaultFontName == null && FontUtilities.debugFonts()) {
357 FontUtilities.logWarning("defaultFontName is null");
358 }
359 defaultFontFileName = fontInfo[1];
360
361 String extraFontPath = fontConfig.getExtraFontPath();
362
363 /* In prior releases the debugging font path replaced
364 * all normally located font directories except for the
365 * JRE fonts dir. This directory is still always located
366 * and placed at the head of the path but as an
367 * augmentation to the previous behaviour the
368 * changes below allow you to additionally append to
369 * the font path by starting with append: or prepend by
370 * starting with a prepend: sign. Eg: to append
371 * -Dsun.java2d.fontpath=append:/usr/local/myfonts
372 * and to prepend
373 * -Dsun.java2d.fontpath=prepend:/usr/local/myfonts Disp
374 *
375 * If there is an appendedfontpath it in the font
376 * configuration it is used instead of searching the
377 * system for dirs.
378 * The behaviour of append and prepend is then similar
379 * to the normal case. ie it goes after what
380 * you prepend and * before what you append. If the
381 * sun.java2d.fontpath property is used, but it
382 * neither the append or prepend syntaxes is used then
383 * as except for the JRE dir the path is replaced and it
384 * is up to you to make sure that all the right
385 * directories are located. This is platform and
386 * locale-specific so its almost impossible to get
387 * right, so it should be used with caution.
388 */
389 boolean prependToPath = false;
390 boolean appendToPath = false;
391 String dbgFontPath = System.getProperty("sun.java2d.fontpath");
392
393 if (dbgFontPath != null) {
394 if (dbgFontPath.startsWith("prepend:")) {
395 prependToPath = true;
396 dbgFontPath =
397 dbgFontPath.substring("prepend:".length());
398 } else if (dbgFontPath.startsWith("append:")) {
399 appendToPath = true;
400 dbgFontPath =
401 dbgFontPath.substring("append:".length());
402 }
403 }
404
405 if (FontUtilities.debugFonts()) {
406 FontUtilities.logInfo("JRE font directory: " + jreFontDirName);
407 FontUtilities.logInfo("Extra font path: " + extraFontPath);
408 FontUtilities.logInfo("Debug font path: " + dbgFontPath);
409 }
410
411 if (dbgFontPath != null) {
412 /* In debugging mode we register all the paths
413 * Caution: this is a very expensive call on Solaris:-
414 */
415 fontPath = getPlatformFontPath(noType1Font);
416
417 if (extraFontPath != null) {
418 fontPath = extraFontPath + File.pathSeparator + fontPath;
419 }
420 if (appendToPath) {
421 fontPath += File.pathSeparator + dbgFontPath;
422 } else if (prependToPath) {
423 fontPath = dbgFontPath + File.pathSeparator + fontPath;
424 } else {
425 fontPath = dbgFontPath;
426 }
427 registerFontDirs(fontPath);
428 } else if (extraFontPath != null) {
429 /* If the font configuration contains an
430 * "appendedfontpath" entry, it is interpreted as a
431 * set of locations that should always be registered.
432 * It may be additional to locations normally found
433 * for that place, or it may be locations that need
434 * to have all their paths registered to locate all
435 * the needed platform names.
436 * This is typically when the same .TTF file is
437 * referenced from multiple font.dir files and all
438 * of these must be read to find all the native
439 * (XLFD) names for the font, so that X11 font APIs
440 * can be used for as many code points as possible.
441 */
442 registerFontDirs(extraFontPath);
443 }
444
445 initCompositeFonts(fontConfig, null);
446
447 return null;
448 }
449 });
450
451 boolean platformFont = AccessController.doPrivileged(
452 new PrivilegedAction<Boolean>() {
453 public Boolean run() {
454 String prop = System.getProperty("java2d.font.usePlatformFont");
455 String env = System.getenv("JAVA2D_USEPLATFORMFONT");
456 return "true".equals(prop) || env != null;
457 }
458 });
459
460 if (platformFont) {
461 usePlatformFontMetrics = true;
462 System.out.println("Enabling platform font metrics for win32. This is an unsupported option.");
463 System.out.println("This yields incorrect composite font metrics as reported by 1.1.x releases.");
464 System.out.println("It is appropriate only for use by applications which do not use any Java 2");
465 System.out.println("functionality. This property will be removed in a later release.");
466 }
467 }
468
469 public Font2DHandle getNewComposite(String family, int style,
470 Font2DHandle handle) {
471
472 if (!(handle.font2D instanceof CompositeFont)) {
473 return handle;
474 }
475
476 CompositeFont oldComp = (CompositeFont)handle.font2D;
477 PhysicalFont oldFont = oldComp.getSlotFont(0);
478
479 if (family == null) {
480 family = oldFont.getFamilyName(null);
481 }
482 if (style == -1) {
483 style = oldComp.getStyle();
484 }
485
486 Font2D newFont = findFont2D(family, style, NO_FALLBACK);
487 if (!(newFont instanceof PhysicalFont)) {
488 newFont = oldFont;
489 }
490 PhysicalFont physicalFont = (PhysicalFont)newFont;
491 CompositeFont dialog2D =
492 (CompositeFont)findFont2D("dialog", style, NO_FALLBACK);
493 if (dialog2D == null) { /* shouldn't happen */
494 return handle;
495 }
496 CompositeFont compFont = new CompositeFont(physicalFont, dialog2D);
497 Font2DHandle newHandle = new Font2DHandle(compFont);
498 return newHandle;
499 }
500
501 protected void registerCompositeFont(String compositeName,
502 String[] componentFileNames,
503 String[] componentNames,
504 int numMetricsSlots,
505 int[] exclusionRanges,
506 int[] exclusionMaxIndex,
507 boolean defer) {
508
509 CompositeFont cf = new CompositeFont(compositeName,
510 componentFileNames,
511 componentNames,
512 numMetricsSlots,
513 exclusionRanges,
514 exclusionMaxIndex, defer, this);
515 addCompositeToFontList(cf, Font2D.FONT_CONFIG_RANK);
516 synchronized (compFonts) {
517 compFonts[maxCompFont++] = cf;
518 }
519 }
520
521 /* This variant is used only when the application specifies
522 * a variant of composite fonts which prefers locale specific or
523 * proportional fonts.
524 */
525 protected static void registerCompositeFont(String compositeName,
526 String[] componentFileNames,
527 String[] componentNames,
528 int numMetricsSlots,
529 int[] exclusionRanges,
530 int[] exclusionMaxIndex,
531 boolean defer,
532 ConcurrentHashMap<String, Font2D>
533 altNameCache) {
534
535 CompositeFont cf = new CompositeFont(compositeName,
536 componentFileNames,
537 componentNames,
538 numMetricsSlots,
539 exclusionRanges,
540 exclusionMaxIndex, defer,
541 SunFontManager.getInstance());
542
543 /* if the cache has an existing composite for this case, make
544 * its handle point to this new font.
545 * This ensures that when the altNameCache that is passed in
546 * is the global mapNameCache - ie we are running as an application -
547 * that any statically created java.awt.Font instances which already
548 * have a Font2D instance will have that re-directed to the new Font
549 * on subsequent uses. This is particularly important for "the"
550 * default font instance, or similar cases where a UI toolkit (eg
551 * Swing) has cached a java.awt.Font. Note that if Swing is using
552 * a custom composite APIs which update the standard composites have
553 * no effect - this is typically the case only when using the Windows
554 * L&F where these APIs would conflict with that L&F anyway.
555 */
556 Font2D oldFont =altNameCache.get(compositeName.toLowerCase(Locale.ENGLISH));
557 if (oldFont instanceof CompositeFont) {
558 oldFont.handle.font2D = cf;
559 }
560 altNameCache.put(compositeName.toLowerCase(Locale.ENGLISH), cf);
561 }
562
563 private void addCompositeToFontList(CompositeFont f, int rank) {
564 if (FontUtilities.isLogging()) {
565 FontUtilities.logInfo("Add to Family "+ f.familyName +
566 ", Font " + f.fullName + " rank="+rank);
567 }
568 f.setRank(rank);
569 compositeFonts.put(f.fullName, f);
570 fullNameToFont.put(f.fullName.toLowerCase(Locale.ENGLISH), f);
571
572 FontFamily family = FontFamily.getFamily(f.familyName);
573 if (family == null) {
574 family = new FontFamily(f.familyName, true, rank);
575 }
576 family.setFont(f, f.style);
577 }
578
579 /*
580 * Systems may have fonts with the same name.
581 * We want to register only one of such fonts (at least until
582 * such time as there might be APIs which can accommodate > 1).
583 * Rank is 1) font configuration fonts, 2) JRE fonts, 3) OT/TT fonts,
584 * 4) Type1 fonts, 5) native fonts.
585 *
586 * If the new font has the same name as the old font, the higher
587 * ranked font gets added, replacing the lower ranked one.
588 * If the fonts are of equal rank, then make a special case of
589 * font configuration rank fonts, which are on closer inspection,
590 * OT/TT fonts such that the larger font is registered. This is
591 * a heuristic since a font may be "larger" in the sense of more
592 * code points, or be a larger "file" because it has more bitmaps.
593 * So it is possible that using filesize may lead to less glyphs, and
594 * using glyphs may lead to lower quality display. Probably number
595 * of glyphs is the ideal, but filesize is information we already
596 * have and is good enough for the known cases.
597 * Also don't want to register fonts that match JRE font families
598 * but are coming from a source other than the JRE.
599 * This will ensure that we will algorithmically style the JRE
600 * plain font and get the same set of glyphs for all styles.
601 *
602 * Note that this method returns a value
603 * if it returns the same object as its argument that means this
604 * font was newly registered.
605 * If it returns a different object it means this font already exists,
606 * and you should use that one.
607 * If it returns null means this font was not registered and none
608 * in that name is registered. The caller must find a substitute
609 */
610 // MACOSX begin -- need to access this in subclass
611 protected PhysicalFont addToFontList(PhysicalFont f, int rank) {
612 // MACOSX end
613
614 String fontName = f.fullName;
615 String familyName = f.familyName;
616 if (fontName == null || fontName.isEmpty()) {
617 return null;
618 }
619 if (compositeFonts.containsKey(fontName)) {
620 /* Don't register any font that has the same name as a composite */
621 return null;
622 }
623 f.setRank(rank);
624 if (!physicalFonts.containsKey(fontName)) {
625 if (FontUtilities.isLogging()) {
626 FontUtilities.logInfo("Add to Family "+familyName +
627 ", Font " + fontName + " rank="+rank);
628 }
629 physicalFonts.put(fontName, f);
630 FontFamily family = FontFamily.getFamily(familyName);
631 if (family == null) {
632 family = new FontFamily(familyName, false, rank);
633 family.setFont(f, f.style);
634 } else {
635 family.setFont(f, f.style);
636 }
637 fullNameToFont.put(fontName.toLowerCase(Locale.ENGLISH), f);
638 return f;
639 } else {
640 PhysicalFont newFont = f;
641 PhysicalFont oldFont = physicalFonts.get(fontName);
642 if (oldFont == null) {
643 return null;
644 }
645 /* If the new font is of an equal or higher rank, it is a
646 * candidate to replace the current one, subject to further tests.
647 */
648 if (oldFont.getRank() >= rank) {
649
650 /* All fonts initialise their mapper when first
651 * used. If the mapper is non-null then this font
652 * has been accessed at least once. In that case
653 * do not replace it. This may be overly stringent,
654 * but its probably better not to replace a font that
655 * someone is already using without a compelling reason.
656 * Additionally the primary case where it is known
657 * this behaviour is important is in certain composite
658 * fonts, and since all the components of a given
659 * composite are usually initialised together this
660 * is unlikely. For this to be a problem, there would
661 * have to be a case where two different composites used
662 * different versions of the same-named font, and they
663 * were initialised and used at separate times.
664 * In that case we continue on and allow the new font to
665 * be installed, but replaceFont will continue to allow
666 * the original font to be used in Composite fonts.
667 */
668 if (oldFont.mapper != null && rank > Font2D.FONT_CONFIG_RANK) {
669 return oldFont;
670 }
671
672 /* Normally we require a higher rank to replace a font,
673 * but as a special case, if the two fonts are the same rank,
674 * and are instances of TrueTypeFont we want the
675 * more complete (larger) one.
676 */
677 if (oldFont.getRank() == rank) {
678 if (oldFont instanceof TrueTypeFont &&
679 newFont instanceof TrueTypeFont) {
680 TrueTypeFont oldTTFont = (TrueTypeFont)oldFont;
681 TrueTypeFont newTTFont = (TrueTypeFont)newFont;
682 if (oldTTFont.fileSize >= newTTFont.fileSize) {
683 return oldFont;
684 }
685 } else {
686 return oldFont;
687 }
688 }
689 /* Don't replace ever JRE fonts.
690 * This test is in case a font configuration references
691 * a Lucida font, which has been mapped to a Lucida
692 * from the host O/S. The assumption here is that any
693 * such font configuration file is probably incorrect, or
694 * the host O/S version is for the use of AWT.
695 * In other words if we reach here, there's a possible
696 * problem with our choice of font configuration fonts.
697 */
698 if (oldFont.platName.startsWith(jreFontDirName)) {
699 if (FontUtilities.isLogging()) {
700 FontUtilities.logWarning("Unexpected attempt to replace a JRE " +
701 " font " + fontName + " from " + oldFont.platName +
702 " with " + newFont.platName);
703 }
704 return oldFont;
705 }
706
707 if (FontUtilities.isLogging()) {
708 FontUtilities.logInfo("Replace in Family " + familyName +
709 ",Font " + fontName + " new rank="+rank +
710 " from " + oldFont.platName +
711 " with " + newFont.platName);
712 }
713 replaceFont(oldFont, newFont);
714 physicalFonts.put(fontName, newFont);
715 fullNameToFont.put(fontName.toLowerCase(Locale.ENGLISH),
716 newFont);
717
718 FontFamily family = FontFamily.getFamily(familyName);
719 if (family == null) {
720 family = new FontFamily(familyName, false, rank);
721 family.setFont(newFont, newFont.style);
722 } else {
723 family.setFont(newFont, newFont.style);
724 }
725 return newFont;
726 } else {
727 return oldFont;
728 }
729 }
730 }
731
732 public Font2D[] getRegisteredFonts() {
733 PhysicalFont[] physFonts = getPhysicalFonts();
734 int mcf = maxCompFont; /* for MT-safety */
735 Font2D[] regFonts = new Font2D[physFonts.length+mcf];
736 System.arraycopy(compFonts, 0, regFonts, 0, mcf);
737 System.arraycopy(physFonts, 0, regFonts, mcf, physFonts.length);
738 return regFonts;
739 }
740
741 protected PhysicalFont[] getPhysicalFonts() {
742 return physicalFonts.values().toArray(new PhysicalFont[0]);
743 }
744
745
746 /* The class FontRegistrationInfo is used when a client says not
747 * to register a font immediately. This mechanism is used to defer
748 * initialisation of all the components of composite fonts at JRE
749 * start-up. The CompositeFont class is "aware" of this and when it
750 * is first used it asks for the registration of its components.
751 * Also in the event that any physical font is requested the
752 * deferred fonts are initialised before triggering a search of the
753 * system.
754 * Two maps are used. One to track the deferred fonts. The
755 * other to track the fonts that have been initialised through this
756 * mechanism.
757 */
758
759 private static final class FontRegistrationInfo {
760
761 String fontFilePath;
762 String[] nativeNames;
763 int fontFormat;
764 boolean javaRasterizer;
765 int fontRank;
766
767 FontRegistrationInfo(String fontPath, String[] names, int format,
768 boolean useJavaRasterizer, int rank) {
769 this.fontFilePath = fontPath;
770 this.nativeNames = names;
771 this.fontFormat = format;
772 this.javaRasterizer = useJavaRasterizer;
773 this.fontRank = rank;
774 }
775 }
776
777 private final ConcurrentHashMap<String, FontRegistrationInfo>
778 deferredFontFiles = new ConcurrentHashMap<>();
779 private final ConcurrentHashMap<String, Font2DHandle>
780 initialisedFonts = new ConcurrentHashMap<>();
781
782 /* Remind: possibly enhance initialiseDeferredFonts() to be
783 * optionally given a name and a style and it could stop when it
784 * finds that font - but this would be a problem if two of the
785 * fonts reference the same font face name (cf the Solaris
786 * euro fonts).
787 */
788 protected synchronized void initialiseDeferredFonts() {
789 for (String fileName : deferredFontFiles.keySet()) {
790 initialiseDeferredFont(fileName);
791 }
792 }
793
794 protected synchronized void registerDeferredJREFonts(String jreDir) {
795 for (FontRegistrationInfo info : deferredFontFiles.values()) {
796 if (info.fontFilePath != null &&
797 info.fontFilePath.startsWith(jreDir)) {
798 initialiseDeferredFont(info.fontFilePath);
799 }
800 }
801 }
802
803 public boolean isDeferredFont(String fileName) {
804 return deferredFontFiles.containsKey(fileName);
805 }
806
807 PhysicalFont findJREDeferredFont(String name, int style) {
808
809 /* Iterate over the deferred font files looking for any in the
810 * jre directory that we didn't recognise, open each of these.
811 * In almost all installations this will quickly fall through
812 * because jreOtherFontFiles will be empty.
813 * noOtherJREFontFiles is used so we can skip this block as soon
814 * as its determined that it's not needed - almost always after the
815 * very first time through.
816 */
817 if (noOtherJREFontFiles) {
818 return null;
819 }
820 synchronized (jreFontDirName) {
821 if (jreOtherFontFiles == null) {
822 HashSet<String> otherFontFiles = new HashSet<>();
823 for (String deferredFile : deferredFontFiles.keySet()) {
824 File file = new File(deferredFile);
825 String dir = file.getParent();
826 /* skip names which aren't absolute, aren't in the JRE
827 * directory, or are known Lucida fonts.
828 */
829 if (dir == null || !dir.equals(jreFontDirName)) {
830 continue;
831 }
832 otherFontFiles.add(deferredFile);
833 }
834 jreOtherFontFiles = otherFontFiles.toArray(STR_ARRAY);
835 if (jreOtherFontFiles.length == 0) {
836 noOtherJREFontFiles = true;
837 }
838 }
839
840 for (int i=0; i<jreOtherFontFiles.length;i++) {
841 String fileName = jreOtherFontFiles[i];
842 if (fileName == null) {
843 continue;
844 }
845 jreOtherFontFiles[i] = null;
846 PhysicalFont physicalFont = initialiseDeferredFont(fileName);
847 if (physicalFont != null &&
848 (physicalFont.getFontName(null).equalsIgnoreCase(name) ||
849 physicalFont.getFamilyName(null).equalsIgnoreCase(name))
850 && physicalFont.style == style) {
851 return physicalFont;
852 }
853 }
854 }
855
856 return null;
857 }
858
859 private PhysicalFont findOtherDeferredFont(String name, int style) {
860 for (String fileName : deferredFontFiles.keySet()) {
861 PhysicalFont physicalFont = initialiseDeferredFont(fileName);
862 if (physicalFont != null &&
863 (physicalFont.getFontName(null).equalsIgnoreCase(name) ||
864 physicalFont.getFamilyName(null).equalsIgnoreCase(name)) &&
865 physicalFont.style == style) {
866 return physicalFont;
867 }
868 }
869 return null;
870 }
871
872 private PhysicalFont findDeferredFont(String name, int style) {
873 PhysicalFont physicalFont = findJREDeferredFont(name, style);
874 if (physicalFont != null) {
875 return physicalFont;
876 } else {
877 return findOtherDeferredFont(name, style);
878 }
879 }
880
881 public void registerDeferredFont(String fileNameKey,
882 String fullPathName,
883 String[] nativeNames,
884 int fontFormat,
885 boolean useJavaRasterizer,
886 int fontRank) {
887 FontRegistrationInfo regInfo =
888 new FontRegistrationInfo(fullPathName, nativeNames, fontFormat,
889 useJavaRasterizer, fontRank);
890 deferredFontFiles.put(fileNameKey, regInfo);
891 }
892
893
894 public synchronized
895 PhysicalFont initialiseDeferredFont(String fileNameKey) {
896
897 if (fileNameKey == null) {
898 return null;
899 }
900 if (FontUtilities.isLogging()) {
901 FontUtilities.logInfo("Opening deferred font file " + fileNameKey);
902 }
903
904 PhysicalFont physicalFont = null;
905 FontRegistrationInfo regInfo = deferredFontFiles.get(fileNameKey);
906 if (regInfo != null) {
907 deferredFontFiles.remove(fileNameKey);
908 physicalFont = registerFontFile(regInfo.fontFilePath,
909 regInfo.nativeNames,
910 regInfo.fontFormat,
911 regInfo.javaRasterizer,
912 regInfo.fontRank);
913
914 if (physicalFont != null) {
915 /* Store the handle, so that if a font is bad, we
916 * retrieve the substituted font.
917 */
918 initialisedFonts.put(fileNameKey, physicalFont.handle);
919 } else {
920 initialisedFonts.put(fileNameKey, FONT_HANDLE_NULL);
921 }
922 } else {
923 Font2DHandle handle = initialisedFonts.get(fileNameKey);
924 if (handle == null) {
925 /* Probably shouldn't happen, but just in case */
926 initialisedFonts.put(fileNameKey, FONT_HANDLE_NULL);
927 } else {
928 physicalFont = (PhysicalFont)(handle.font2D);
929 }
930 }
931 return physicalFont;
932 }
933
934 public boolean isRegisteredFontFile(String name) {
935 return registeredFonts.containsKey(name);
936 }
937
938 public PhysicalFont getRegisteredFontFile(String name) {
939 return registeredFonts.get(name);
940 }
941
942 /* Note that the return value from this method is not always
943 * derived from this file, and may be null. See addToFontList for
944 * some explanation of this.
945 */
946 public PhysicalFont registerFontFile(String fileName,
947 String[] nativeNames,
948 int fontFormat,
949 boolean useJavaRasterizer,
950 int fontRank) {
951
952 PhysicalFont regFont = registeredFonts.get(fileName);
953 if (regFont != null) {
954 return regFont;
955 }
956
957 PhysicalFont physicalFont = null;
958 try {
959 switch (fontFormat) {
960
961 case FONTFORMAT_TRUETYPE:
962 int fn = 0;
963 TrueTypeFont ttf;
964 do {
965 ttf = new TrueTypeFont(fileName, nativeNames, fn++,
966 useJavaRasterizer);
967 PhysicalFont pf = addToFontList(ttf, fontRank);
968 if (physicalFont == null) {
969 physicalFont = pf;
970 }
971 }
972 while (fn < ttf.getFontCount());
973 break;
974
975 case FONTFORMAT_TYPE1:
976 Type1Font t1f = new Type1Font(fileName, nativeNames);
977 physicalFont = addToFontList(t1f, fontRank);
978 break;
979
980 case FONTFORMAT_NATIVE:
981 NativeFont nf = new NativeFont(fileName, false);
982 physicalFont = addToFontList(nf, fontRank);
983 break;
984 default:
985
986 }
987 if (FontUtilities.isLogging()) {
988 FontUtilities.logInfo("Registered file " + fileName + " as font " +
989 physicalFont + " rank=" + fontRank);
990 }
991 } catch (FontFormatException ffe) {
992 if (FontUtilities.isLogging()) {
993 FontUtilities.logInfo("Unusable font: " + fileName + " " + ffe.toString());
994 }
995 }
996 if (physicalFont != null &&
997 fontFormat != FONTFORMAT_NATIVE) {
998 registeredFonts.put(fileName, physicalFont);
999 }
1000 return physicalFont;
1001 }
1002
1003 public void registerFonts(String[] fileNames,
1004 String[][] nativeNames,
1005 int fontCount,
1006 int fontFormat,
1007 boolean useJavaRasterizer,
1008 int fontRank, boolean defer) {
1009
1010 for (int i=0; i < fontCount; i++) {
1011 if (defer) {
1012 registerDeferredFont(fileNames[i],fileNames[i], nativeNames[i],
1013 fontFormat, useJavaRasterizer, fontRank);
1014 } else {
1015 registerFontFile(fileNames[i], nativeNames[i],
1016 fontFormat, useJavaRasterizer, fontRank);
1017 }
1018 }
1019 }
1020
1021 /*
1022 * This is the Physical font used when some other font on the system
1023 * can't be located. There has to be at least one font or the font
1024 * system is not useful and the graphics environment cannot sustain
1025 * the Java platform.
1026 */
1027 public PhysicalFont getDefaultPhysicalFont() {
1028 if (defaultPhysicalFont == null) {
1029 String defaultFontName = getDefaultFontFaceName();
1030 // findFont2D will load all fonts
1031 Font2D font2d = findFont2D(defaultFontName, Font.PLAIN, NO_FALLBACK);
1032 if (font2d != null) {
1033 if (font2d instanceof PhysicalFont) {
1034 defaultPhysicalFont = (PhysicalFont)font2d;
1035 } else {
1036 if (FontUtilities.isLogging()) {
1037 FontUtilities.logWarning("Font returned by findFont2D for default font name " +
1038 defaultFontName + " is not a physical font: " + font2d.getFontName(null));
1039 }
1040 }
1041 }
1042 if (defaultPhysicalFont == null) {
1043 /* Because of the findFont2D call above, if we reach here, we
1044 * know all fonts have already been loaded, just accept any
1045 * match at this point. If this fails we are in real trouble
1046 * and I don't know how to recover from there being absolutely
1047 * no fonts anywhere on the system.
1048 */
1049 defaultPhysicalFont = physicalFonts.values().stream().findFirst()
1050 .orElseThrow(()->new Error("Probable fatal error: No physical fonts found."));
1051 }
1052 }
1053 return defaultPhysicalFont;
1054 }
1055
1056 public Font2D getDefaultLogicalFont(int style) {
1057 return findFont2D("dialog", style, NO_FALLBACK);
1058 }
1059
1060 /*
1061 * return String representation of style prepended with "."
1062 * This is useful for performance to avoid unnecessary string operations.
1063 */
1064 private static String dotStyleStr(int num) {
1065 switch(num){
1066 case Font.BOLD:
1067 return ".bold";
1068 case Font.ITALIC:
1069 return ".italic";
1070 case Font.ITALIC | Font.BOLD:
1071 return ".bolditalic";
1072 default:
1073 return ".plain";
1074 }
1075 }
1076
1077 /* This is implemented only on windows and is called from code that
1078 * executes only on windows. This isn't pretty but its not a precedent
1079 * in this file. This very probably should be cleaned up at some point.
1080 */
1081 protected void
1082 populateFontFileNameMap(HashMap<String,String> fontToFileMap,
1083 HashMap<String,String> fontToFamilyNameMap,
1084 HashMap<String,ArrayList<String>>
1085 familyToFontListMap,
1086 Locale locale) {
1087 }
1088
1089 /* Obtained from Platform APIs (windows only)
1090 * Map from lower-case font full name to basename of font file.
1091 * Eg "arial bold" -> ARIALBD.TTF.
1092 * For TTC files, there is a mapping for each font in the file.
1093 */
1094 private HashMap<String,String> fontToFileMap = null;
1095
1096 /* Obtained from Platform APIs (windows only)
1097 * Map from lower-case font full name to the name of its font family
1098 * Eg "arial bold" -> "Arial"
1099 */
1100 private HashMap<String,String> fontToFamilyNameMap = null;
1101
1102 /* Obtained from Platform APIs (windows only)
1103 * Map from a lower-case family name to a list of full names of
1104 * the member fonts, eg:
1105 * "arial" -> ["Arial", "Arial Bold", "Arial Italic","Arial Bold Italic"]
1106 */
1107 private HashMap<String,ArrayList<String>> familyToFontListMap= null;
1108
1109 /* The directories which contain platform fonts */
1110 private String[] pathDirs = null;
1111
1112 private boolean haveCheckedUnreferencedFontFiles;
1113
1114 private String[] getFontFilesFromPath(boolean noType1) {
1115 final FilenameFilter filter;
1116 if (noType1) {
1117 filter = ttFilter;
1118 } else {
1119 filter = new TTorT1Filter();
1120 }
1121 return AccessController.doPrivileged(new PrivilegedAction<String[]>() {
1122 public String[] run() {
1123 if (pathDirs.length == 1) {
1124 File dir = new File(pathDirs[0]);
1125 String[] files = dir.list(filter);
1126 if (files == null) {
1127 return new String[0];
1128 }
1129 for (int f=0; f<files.length; f++) {
1130 files[f] = files[f].toLowerCase();
1131 }
1132 return files;
1133 } else {
1134 ArrayList<String> fileList = new ArrayList<>();
1135 for (int i = 0; i< pathDirs.length; i++) {
1136 File dir = new File(pathDirs[i]);
1137 String[] files = dir.list(filter);
1138 if (files == null) {
1139 continue;
1140 }
1141 for (int f = 0; f < files.length ; f++) {
1142 fileList.add(files[f].toLowerCase());
1143 }
1144 }
1145 return fileList.toArray(STR_ARRAY);
1146 }
1147 }
1148 });
1149 }
1150
1151 /* This is needed since some windows registry names don't match
1152 * the font names.
1153 * - UPC styled font names have a double space, but the
1154 * registry entry mapping to a file doesn't.
1155 * - Marlett is in a hidden file not listed in the registry
1156 * - The registry advertises that the file david.ttf contains a
1157 * font with the full name "David Regular" when in fact its
1158 * just "David".
1159 * Directly fix up these known cases as this is faster.
1160 * If a font which doesn't match these known cases has no file,
1161 * it may be a font that has been temporarily added to the known set
1162 * or it may be an installed font with a missing registry entry.
1163 * Installed fonts are those in the windows font directories.
1164 * Make a best effort attempt to locate these.
1165 * We obtain the list of TrueType fonts in these directories and
1166 * filter out all the font files we already know about from the registry.
1167 * What remains may be "bad" fonts, duplicate fonts, or perhaps the
1168 * missing font(s) we are looking for.
1169 * Open each of these files to find out.
1170 */
1171 private void resolveWindowsFonts() {
1172
1173 ArrayList<String> unmappedFontNames = null;
1174 for (String font : fontToFamilyNameMap.keySet()) {
1175 String file = fontToFileMap.get(font);
1176 if (file == null) {
1177 if (font.indexOf(" ") > 0) {
1178 String newName = font.replaceFirst(" ", " ");
1179 file = fontToFileMap.get(newName);
1180 /* If this name exists and isn't for a valid name
1181 * replace the mapping to the file with this font
1182 */
1183 if (file != null &&
1184 !fontToFamilyNameMap.containsKey(newName)) {
1185 fontToFileMap.remove(newName);
1186 fontToFileMap.put(font, file);
1187 }
1188 } else if (font.equals("marlett")) {
1189 fontToFileMap.put(font, "marlett.ttf");
1190 } else if (font.equals("david")) {
1191 file = fontToFileMap.get("david regular");
1192 if (file != null) {
1193 fontToFileMap.remove("david regular");
1194 fontToFileMap.put("david", file);
1195 }
1196 } else {
1197 if (unmappedFontNames == null) {
1198 unmappedFontNames = new ArrayList<>();
1199 }
1200 unmappedFontNames.add(font);
1201 }
1202 }
1203 }
1204
1205 if (unmappedFontNames != null) {
1206 HashSet<String> unmappedFontFiles = new HashSet<>();
1207
1208 /* Every font key in fontToFileMap ought to correspond to a
1209 * font key in fontToFamilyNameMap. Entries that don't seem
1210 * to correspond are likely fonts that were named differently
1211 * by GDI than in the registry. One known cause of this is when
1212 * Windows has had its regional settings changed so that from
1213 * GDI we get a localised (eg Chinese or Japanese) name for the
1214 * font, but the registry retains the English version of the name
1215 * that corresponded to the "install" locale for windows.
1216 * Since we are in this code block because there are unmapped
1217 * font names, we can look to find unused font->file mappings
1218 * and then open the files to read the names. We don't generally
1219 * want to open font files, as its a performance hit, but this
1220 * occurs only for a small number of fonts on specific system
1221 * configs - ie is believed that a "true" Japanese windows would
1222 * have JA names in the registry too.
1223 * Clone fontToFileMap and remove from the clone all keys which
1224 * match a fontToFamilyNameMap key. What remains maps to the
1225 * files we want to open to find the fonts GDI returned.
1226 * A font in such a file is added to the fontToFileMap after
1227 * checking its one of the unmappedFontNames we are looking for.
1228 * The original name that didn't map is removed from fontToFileMap
1229 * so essentially this "fixes up" fontToFileMap to use the same
1230 * name as GDI.
1231 * Also note that typically the fonts for which this occurs in
1232 * CJK locales are TTC fonts and not all fonts in a TTC may have
1233 * localised names. Eg MSGOTHIC.TTC contains 3 fonts and one of
1234 * them "MS UI Gothic" has no JA name whereas the other two do.
1235 * So not every font in these files is unmapped or new.
1236 */
1237 @SuppressWarnings("unchecked")
1238 HashMap<String,String> ffmapCopy =
1239 (HashMap<String,String>)(fontToFileMap.clone());
1240 for (String key : fontToFamilyNameMap.keySet()) {
1241 ffmapCopy.remove(key);
1242 }
1243 for (String key : ffmapCopy.keySet()) {
1244 unmappedFontFiles.add(ffmapCopy.get(key));
1245 fontToFileMap.remove(key);
1246 }
1247
1248 resolveFontFiles(unmappedFontFiles, unmappedFontNames);
1249
1250 /* If there are still unmapped font names, this means there's
1251 * something that wasn't in the registry. We need to get all
1252 * the font files directly and look at the ones that weren't
1253 * found in the registry.
1254 */
1255 if (unmappedFontNames.size() > 0) {
1256
1257 /* getFontFilesFromPath() returns all lower case names.
1258 * To compare we also need lower case
1259 * versions of the names from the registry.
1260 */
1261 ArrayList<String> registryFiles = new ArrayList<>();
1262
1263 for (String regFile : fontToFileMap.values()) {
1264 registryFiles.add(regFile.toLowerCase());
1265 }
1266 /* We don't look for Type1 files here as windows will
1267 * not enumerate these, so aren't useful in reconciling
1268 * GDI's unmapped files. We do find these later when
1269 * we enumerate all fonts.
1270 */
1271 for (String pathFile : getFontFilesFromPath(true)) {
1272 if (!registryFiles.contains(pathFile)) {
1273 unmappedFontFiles.add(pathFile);
1274 }
1275 }
1276
1277 resolveFontFiles(unmappedFontFiles, unmappedFontNames);
1278 }
1279
1280 /* remove from the set of names that will be returned to the
1281 * user any fonts that can't be mapped to files.
1282 */
1283 if (unmappedFontNames.size() > 0) {
1284 int sz = unmappedFontNames.size();
1285 for (int i=0; i<sz; i++) {
1286 String name = unmappedFontNames.get(i);
1287 String familyName = fontToFamilyNameMap.get(name);
1288 if (familyName != null) {
1289 ArrayList<String> family = familyToFontListMap.get(familyName);
1290 if (family != null) {
1291 if (family.size() <= 1) {
1292 familyToFontListMap.remove(familyName);
1293 }
1294 }
1295 }
1296 fontToFamilyNameMap.remove(name);
1297 if (FontUtilities.isLogging()) {
1298 FontUtilities.logInfo("No file for font:" + name);
1299 }
1300 }
1301 }
1302 }
1303 }
1304
1305 /**
1306 * In some cases windows may have fonts in the fonts folder that
1307 * don't show up in the registry or in the GDI calls to enumerate fonts.
1308 * The only way to find these is to list the directory. We invoke this
1309 * only in getAllFonts/Families, so most searches for a specific
1310 * font that is satisfied by the GDI/registry calls don't take the
1311 * additional hit of listing the directory. This hit is small enough
1312 * that its not significant in these 'enumerate all the fonts' cases.
1313 * The basic approach is to cross-reference the files windows found
1314 * with the ones in the directory listing approach, and for each
1315 * in the latter list that is missing from the former list, register it.
1316 */
1317 private synchronized void checkForUnreferencedFontFiles() {
1318 if (haveCheckedUnreferencedFontFiles) {
1319 return;
1320 }
1321 haveCheckedUnreferencedFontFiles = true;
1322 if (!FontUtilities.isWindows) {
1323 return;
1324 }
1325 /* getFontFilesFromPath() returns all lower case names.
1326 * To compare we also need lower case
1327 * versions of the names from the registry.
1328 */
1329 ArrayList<String> registryFiles = new ArrayList<>();
1330 for (String regFile : fontToFileMap.values()) {
1331 registryFiles.add(regFile.toLowerCase());
1332 }
1333
1334 /* To avoid any issues with concurrent modification, create
1335 * copies of the existing maps, add the new fonts into these
1336 * and then replace the references to the old ones with the
1337 * new maps. ConcurrentHashmap is another option but its a lot
1338 * more changes and with this exception, these maps are intended
1339 * to be static.
1340 */
1341 HashMap<String,String> fontToFileMap2 = null;
1342 HashMap<String,String> fontToFamilyNameMap2 = null;
1343 HashMap<String,ArrayList<String>> familyToFontListMap2 = null;;
1344
1345 for (String pathFile : getFontFilesFromPath(false)) {
1346 if (!registryFiles.contains(pathFile)) {
1347 if (FontUtilities.isLogging()) {
1348 FontUtilities.logInfo("Found non-registry file : " + pathFile);
1349 }
1350 PhysicalFont f = registerFontFile(getPathName(pathFile));
1351 if (f == null) {
1352 continue;
1353 }
1354 if (fontToFileMap2 == null) {
1355 fontToFileMap2 = new HashMap<>(fontToFileMap);
1356 fontToFamilyNameMap2 = new HashMap<>(fontToFamilyNameMap);
1357 familyToFontListMap2 = new HashMap<>(familyToFontListMap);
1358 }
1359 String fontName = f.getFontName(null);
1360 String family = f.getFamilyName(null);
1361 String familyLC = family.toLowerCase();
1362 fontToFamilyNameMap2.put(fontName, family);
1363 fontToFileMap2.put(fontName, pathFile);
1364 ArrayList<String> fonts = familyToFontListMap2.get(familyLC);
1365 if (fonts == null) {
1366 fonts = new ArrayList<>();
1367 } else {
1368 fonts = new ArrayList<>(fonts);
1369 }
1370 fonts.add(fontName);
1371 familyToFontListMap2.put(familyLC, fonts);
1372 }
1373 }
1374 if (fontToFileMap2 != null) {
1375 fontToFileMap = fontToFileMap2;
1376 familyToFontListMap = familyToFontListMap2;
1377 fontToFamilyNameMap = fontToFamilyNameMap2;
1378 }
1379 }
1380
1381 private void resolveFontFiles(HashSet<String> unmappedFiles,
1382 ArrayList<String> unmappedFonts) {
1383
1384 Locale l = SunToolkit.getStartupLocale();
1385
1386 for (String file : unmappedFiles) {
1387 try {
1388 int fn = 0;
1389 TrueTypeFont ttf;
1390 String fullPath = getPathName(file);
1391 if (FontUtilities.isLogging()) {
1392 FontUtilities.logInfo("Trying to resolve file " + fullPath);
1393 }
1394 do {
1395 ttf = new TrueTypeFont(fullPath, null, fn++, false);
1396 // prefer the font's locale name.
1397 String fontName = ttf.getFontName(l).toLowerCase();
1398 if (unmappedFonts.contains(fontName)) {
1399 fontToFileMap.put(fontName, file);
1400 unmappedFonts.remove(fontName);
1401 if (FontUtilities.isLogging()) {
1402 FontUtilities.logInfo("Resolved absent registry entry for " +
1403 fontName + " located in " + fullPath);
1404 }
1405 }
1406 }
1407 while (fn < ttf.getFontCount());
1408 } catch (Exception e) {
1409 }
1410 }
1411 }
1412
1413 /* Hardwire the English names and expected file names of fonts
1414 * commonly used at start up. Avoiding until later even the small
1415 * cost of calling platform APIs to locate these can help.
1416 * The code that registers these fonts needs to "bail" if any
1417 * of the files do not exist, so it will verify the existence of
1418 * all non-null file names first.
1419 * They are added in to a map with nominally the first
1420 * word in the name of the family as the key. In all the cases
1421 * we are using the family name is a single word, and as is
1422 * more or less required the family name is the initial sequence
1423 * in a full name. So lookup first finds the matching description,
1424 * then registers the whole family, returning the right font.
1425 */
1426 public static class FamilyDescription {
1427 public String familyName;
1428 public String plainFullName;
1429 public String boldFullName;
1430 public String italicFullName;
1431 public String boldItalicFullName;
1432 public String plainFileName;
1433 public String boldFileName;
1434 public String italicFileName;
1435 public String boldItalicFileName;
1436 }
1437
1438 static HashMap<String, FamilyDescription> platformFontMap;
1439
1440 /**
1441 * default implementation does nothing.
1442 */
1443 public HashMap<String, FamilyDescription> populateHardcodedFileNameMap() {
1444 return new HashMap<>(0);
1445 }
1446
1447 Font2D findFontFromPlatformMap(String lcName, int style) {
1448 if (platformFontMap == null) {
1449 platformFontMap = populateHardcodedFileNameMap();
1450 }
1451
1452 if (platformFontMap == null || platformFontMap.size() == 0) {
1453 return null;
1454 }
1455
1456 int spaceIndex = lcName.indexOf(' ');
1457 String firstWord = lcName;
1458 if (spaceIndex > 0) {
1459 firstWord = lcName.substring(0, spaceIndex);
1460 }
1461
1462 FamilyDescription fd = platformFontMap.get(firstWord);
1463 if (fd == null) {
1464 return null;
1465 }
1466 /* Once we've established that its at least the first word,
1467 * we need to dig deeper to make sure its a match for either
1468 * a full name, or the family name, to make sure its not
1469 * a request for some other font that just happens to start
1470 * with the same first word.
1471 */
1472 int styleIndex = -1;
1473 if (lcName.equalsIgnoreCase(fd.plainFullName)) {
1474 styleIndex = 0;
1475 } else if (lcName.equalsIgnoreCase(fd.boldFullName)) {
1476 styleIndex = 1;
1477 } else if (lcName.equalsIgnoreCase(fd.italicFullName)) {
1478 styleIndex = 2;
1479 } else if (lcName.equalsIgnoreCase(fd.boldItalicFullName)) {
1480 styleIndex = 3;
1481 }
1482 if (styleIndex == -1 && !lcName.equalsIgnoreCase(fd.familyName)) {
1483 return null;
1484 }
1485
1486 String plainFile = null, boldFile = null,
1487 italicFile = null, boldItalicFile = null;
1488
1489 boolean failure = false;
1490 /* In a terminal server config, its possible that getPathName()
1491 * will return null, if the file doesn't exist, hence the null
1492 * checks on return. But in the normal client config we need to
1493 * follow this up with a check to see if all the files really
1494 * exist for the non-null paths.
1495 */
1496 getPlatformFontDirs(noType1Font);
1497
1498 if (fd.plainFileName != null) {
1499 plainFile = getPathName(fd.plainFileName);
1500 if (plainFile == null) {
1501 failure = true;
1502 }
1503 }
1504
1505 if (fd.boldFileName != null) {
1506 boldFile = getPathName(fd.boldFileName);
1507 if (boldFile == null) {
1508 failure = true;
1509 }
1510 }
1511
1512 if (fd.italicFileName != null) {
1513 italicFile = getPathName(fd.italicFileName);
1514 if (italicFile == null) {
1515 failure = true;
1516 }
1517 }
1518
1519 if (fd.boldItalicFileName != null) {
1520 boldItalicFile = getPathName(fd.boldItalicFileName);
1521 if (boldItalicFile == null) {
1522 failure = true;
1523 }
1524 }
1525
1526 if (failure) {
1527 if (FontUtilities.isLogging()) {
1528 FontUtilities.logInfo("Hardcoded file missing looking for " + lcName);
1529 }
1530 platformFontMap.remove(firstWord);
1531 return null;
1532 }
1533
1534 /* Some of these may be null,as not all styles have to exist */
1535 final String[] files = {
1536 plainFile, boldFile, italicFile, boldItalicFile } ;
1537
1538 failure = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
1539 public Boolean run() {
1540 for (int i=0; i<files.length; i++) {
1541 if (files[i] == null) {
1542 continue;
1543 }
1544 File f = new File(files[i]);
1545 if (!f.exists()) {
1546 return Boolean.TRUE;
1547 }
1548 }
1549 return Boolean.FALSE;
1550 }
1551 });
1552
1553 if (failure) {
1554 if (FontUtilities.isLogging()) {
1555 FontUtilities.logInfo("Hardcoded file missing looking for " + lcName);
1556 }
1557 platformFontMap.remove(firstWord);
1558 return null;
1559 }
1560
1561 /* If we reach here we know that we have all the files we
1562 * expect, so all should be fine so long as the contents
1563 * are what we'd expect. Now on to registering the fonts.
1564 * Currently this code only looks for TrueType fonts, so format
1565 * and rank can be specified without looking at the filename.
1566 */
1567 Font2D font = null;
1568 for (int f=0;f<files.length;f++) {
1569 if (files[f] == null) {
1570 continue;
1571 }
1572 PhysicalFont pf =
1573 registerFontFile(files[f], null,
1574 FONTFORMAT_TRUETYPE, false, Font2D.TTF_RANK);
1575 if (f == styleIndex) {
1576 font = pf;
1577 }
1578 }
1579
1580
1581 /* Two general cases need a bit more work here.
1582 * 1) If font is null, then it was perhaps a request for a
1583 * non-existent font, such as "Tahoma Italic", or a family name -
1584 * where family and full name of the plain font differ.
1585 * Fall back to finding the closest one in the family.
1586 * This could still fail if a client specified "Segoe" instead of
1587 * "Segoe UI".
1588 * 2) The request is of the form "MyFont Bold", style=Font.ITALIC,
1589 * and so we want to see if there's a Bold Italic font, or
1590 * "MyFamily", style=Font.BOLD, and we may have matched the plain,
1591 * but now need to revise that to the BOLD font.
1592 */
1593 FontFamily fontFamily = FontFamily.getFamily(fd.familyName);
1594 if (fontFamily != null) {
1595 if (font == null) {
1596 font = fontFamily.getFont(style);
1597 if (font == null) {
1598 font = fontFamily.getClosestStyle(style);
1599 }
1600 } else if (style > 0 && style != font.style) {
1601 style |= font.style;
1602 font = fontFamily.getFont(style);
1603 if (font == null) {
1604 font = fontFamily.getClosestStyle(style);
1605 }
1606 }
1607 }
1608
1609 return font;
1610 }
1611 private synchronized HashMap<String,String> getFullNameToFileMap() {
1612 if (fontToFileMap == null) {
1613
1614 pathDirs = getPlatformFontDirs(noType1Font);
1615
1616 fontToFileMap = new HashMap<>(100);
1617 fontToFamilyNameMap = new HashMap<>(100);
1618 familyToFontListMap = new HashMap<>(50);
1619 populateFontFileNameMap(fontToFileMap,
1620 fontToFamilyNameMap,
1621 familyToFontListMap,
1622 Locale.ENGLISH);
1623 if (FontUtilities.isWindows) {
1624 resolveWindowsFonts();
1625 }
1626 if (FontUtilities.isLogging()) {
1627 logPlatformFontInfo();
1628 }
1629 }
1630 return fontToFileMap;
1631 }
1632
1633 private void logPlatformFontInfo() {
1634 PlatformLogger logger = FontUtilities.getLogger();
1635 for (int i=0; i< pathDirs.length;i++) {
1636 logger.info("fontdir="+pathDirs[i]);
1637 }
1638 for (String keyName : fontToFileMap.keySet()) {
1639 logger.info("font="+keyName+" file="+ fontToFileMap.get(keyName));
1640 }
1641 for (String keyName : fontToFamilyNameMap.keySet()) {
1642 logger.info("font="+keyName+" family="+
1643 fontToFamilyNameMap.get(keyName));
1644 }
1645 for (String keyName : familyToFontListMap.keySet()) {
1646 logger.info("family="+keyName+ " fonts="+
1647 familyToFontListMap.get(keyName));
1648 }
1649 }
1650
1651 /* Note this return list excludes logical fonts and JRE fonts */
1652 protected String[] getFontNamesFromPlatform() {
1653 if (getFullNameToFileMap().size() == 0) {
1654 return null;
1655 }
1656 checkForUnreferencedFontFiles();
1657 /* This odd code with TreeMap is used to preserve a historical
1658 * behaviour wrt the sorting order .. */
1659 ArrayList<String> fontNames = new ArrayList<>();
1660 for (ArrayList<String> a : familyToFontListMap.values()) {
1661 for (String s : a) {
1662 fontNames.add(s);
1663 }
1664 }
1665 return fontNames.toArray(STR_ARRAY);
1666 }
1667
1668 public boolean gotFontsFromPlatform() {
1669 return getFullNameToFileMap().size() != 0;
1670 }
1671
1672 public String getFileNameForFontName(String fontName) {
1673 String fontNameLC = fontName.toLowerCase(Locale.ENGLISH);
1674 return fontToFileMap.get(fontNameLC);
1675 }
1676
1677 private PhysicalFont registerFontFile(String file) {
1678 if (new File(file).isAbsolute() &&
1679 !registeredFonts.containsKey(file)) {
1680 int fontFormat = FONTFORMAT_NONE;
1681 int fontRank = Font2D.UNKNOWN_RANK;
1682 if (ttFilter.accept(null, file)) {
1683 fontFormat = FONTFORMAT_TRUETYPE;
1684 fontRank = Font2D.TTF_RANK;
1685 } else if
1686 (t1Filter.accept(null, file)) {
1687 fontFormat = FONTFORMAT_TYPE1;
1688 fontRank = Font2D.TYPE1_RANK;
1689 }
1690 if (fontFormat == FONTFORMAT_NONE) {
1691 return null;
1692 }
1693 return registerFontFile(file, null, fontFormat, false, fontRank);
1694 }
1695 return null;
1696 }
1697
1698 /* Used to register any font files that are found by platform APIs
1699 * that weren't previously found in the standard font locations.
1700 * the isAbsolute() check is needed since that's whats stored in the
1701 * set, and on windows, the fonts in the system font directory that
1702 * are in the fontToFileMap are just basenames. We don't want to try
1703 * to register those again, but we do want to register other registry
1704 * installed fonts.
1705 */
1706 protected void registerOtherFontFiles(HashSet<String> registeredFontFiles) {
1707 if (getFullNameToFileMap().size() == 0) {
1708 return;
1709 }
1710 for (String file : fontToFileMap.values()) {
1711 registerFontFile(file);
1712 }
1713 }
1714
1715 public boolean
1716 getFamilyNamesFromPlatform(TreeMap<String,String> familyNames,
1717 Locale requestedLocale) {
1718 if (getFullNameToFileMap().size() == 0) {
1719 return false;
1720 }
1721 checkForUnreferencedFontFiles();
1722 for (String name : fontToFamilyNameMap.values()) {
1723 familyNames.put(name.toLowerCase(requestedLocale), name);
1724 }
1725 return true;
1726 }
1727
1728 /* Path may be absolute or a base file name relative to one of
1729 * the platform font directories
1730 */
1731 private String getPathName(final String s) {
1732 File f = new File(s);
1733 if (f.isAbsolute()) {
1734 return s;
1735 } else if (pathDirs.length==1) {
1736 return pathDirs[0] + File.separator + s;
1737 } else {
1738 String path = AccessController.doPrivileged(
1739 new PrivilegedAction<String>() {
1740 public String run() {
1741 for (int p = 0; p < pathDirs.length; p++) {
1742 File f = new File(pathDirs[p] +File.separator+ s);
1743 if (f.exists()) {
1744 return f.getAbsolutePath();
1745 }
1746 }
1747 return null;
1748 }
1749 });
1750 if (path != null) {
1751 return path;
1752 }
1753 }
1754 return s; // shouldn't happen, but harmless
1755 }
1756
1757 /* lcName is required to be lower case for use as a key.
1758 * lcName may be a full name, or a family name, and style may
1759 * be specified in addition to either of these. So be sure to
1760 * get the right one. Since an app *could* ask for "Foo Regular"
1761 * and later ask for "Foo Italic", if we don't register all the
1762 * styles, then logic in findFont2D may try to style the original
1763 * so we register the entire family if we get a match here.
1764 * This is still a big win because this code is invoked where
1765 * otherwise we would register all fonts.
1766 * It's also useful for the case where "Foo Bold" was specified with
1767 * style Font.ITALIC, as we would want in that case to try to return
1768 * "Foo Bold Italic" if it exists, and it is only by locating "Foo Bold"
1769 * and opening it that we really "know" it's Bold, and can look for
1770 * a font that supports that and the italic style.
1771 * The code in here is not overtly windows-specific but in fact it
1772 * is unlikely to be useful as is on other platforms. It is maintained
1773 * in this shared source file to be close to its sole client and
1774 * because so much of the logic is intertwined with the logic in
1775 * findFont2D.
1776 */
1777 private Font2D findFontFromPlatform(String lcName, int style) {
1778 if (getFullNameToFileMap().size() == 0) {
1779 return null;
1780 }
1781
1782 ArrayList<String> family = null;
1783 String fontFile = null;
1784 String familyName = fontToFamilyNameMap.get(lcName);
1785 if (familyName != null) {
1786 fontFile = fontToFileMap.get(lcName);
1787 family = familyToFontListMap.get
1788 (familyName.toLowerCase(Locale.ENGLISH));
1789 } else {
1790 family = familyToFontListMap.get(lcName); // is lcName is a family?
1791 if (family != null && family.size() > 0) {
1792 String lcFontName = family.get(0).toLowerCase(Locale.ENGLISH);
1793 if (lcFontName != null) {
1794 familyName = fontToFamilyNameMap.get(lcFontName);
1795 }
1796 }
1797 }
1798 if (family == null || familyName == null) {
1799 return null;
1800 }
1801 String [] fontList = family.toArray(STR_ARRAY);
1802 if (fontList.length == 0) {
1803 return null;
1804 }
1805
1806 /* first check that for every font in this family we can find
1807 * a font file. The specific reason for doing this is that
1808 * in at least one case on Windows a font has the face name "David"
1809 * but the registry entry is "David Regular". That is the "unique"
1810 * name of the font but in other cases the registry contains the
1811 * "full" name. See the specifications of name ids 3 and 4 in the
1812 * TrueType 'name' table.
1813 * In general this could cause a problem that we fail to register
1814 * if we all members of a family that we may end up mapping to
1815 * the wrong font member: eg return Bold when Plain is needed.
1816 */
1817 for (int f=0;f<fontList.length;f++) {
1818 String fontNameLC = fontList[f].toLowerCase(Locale.ENGLISH);
1819 String fileName = fontToFileMap.get(fontNameLC);
1820 if (fileName == null) {
1821 if (FontUtilities.isLogging()) {
1822 FontUtilities.logInfo("Platform lookup : No file for font " +
1823 fontList[f] + " in family " +familyName);
1824 }
1825 return null;
1826 }
1827 }
1828
1829 /* Currently this code only looks for TrueType fonts, so format
1830 * and rank can be specified without looking at the filename.
1831 */
1832 PhysicalFont physicalFont = null;
1833 if (fontFile != null) {
1834 physicalFont = registerFontFile(getPathName(fontFile), null,
1835 FONTFORMAT_TRUETYPE, false,
1836 Font2D.TTF_RANK);
1837 }
1838 /* Register all fonts in this family. */
1839 for (int f=0;f<fontList.length;f++) {
1840 String fontNameLC = fontList[f].toLowerCase(Locale.ENGLISH);
1841 String fileName = fontToFileMap.get(fontNameLC);
1842 if (fontFile != null && fontFile.equals(fileName)) {
1843 continue;
1844 }
1845 /* Currently this code only looks for TrueType fonts, so format
1846 * and rank can be specified without looking at the filename.
1847 */
1848 registerFontFile(getPathName(fileName), null,
1849 FONTFORMAT_TRUETYPE, false, Font2D.TTF_RANK);
1850 }
1851
1852 Font2D font = null;
1853 FontFamily fontFamily = FontFamily.getFamily(familyName);
1854 /* Handle case where request "MyFont Bold", style=Font.ITALIC */
1855 if (physicalFont != null) {
1856 style |= physicalFont.style;
1857 }
1858 if (fontFamily != null) {
1859 font = fontFamily.getFont(style);
1860 if (font == null) {
1861 font = fontFamily.getClosestStyle(style);
1862 }
1863 }
1864 return font;
1865 }
1866
1867 private ConcurrentHashMap<String, Font2D> fontNameCache =
1868 new ConcurrentHashMap<>();
1869
1870 /*
1871 * The client supplies a name and a style.
1872 * The name could be a family name, or a full name.
1873 * A font may exist with the specified style, or it may
1874 * exist only in some other style. For non-native fonts the scaler
1875 * may be able to emulate the required style.
1876 */
1877 public Font2D findFont2D(String name, int style, int fallback) {
1878 if (name == null) return null;
1879 String lowerCaseName = name.toLowerCase(Locale.ENGLISH);
1880 String mapName = lowerCaseName + dotStyleStr(style);
1881
1882 /* If preferLocaleFonts() or preferProportionalFonts() has been
1883 * called we may be using an alternate set of composite fonts in this
1884 * app context. The presence of a pre-built name map indicates whether
1885 * this is so, and gives access to the alternate composite for the
1886 * name.
1887 */
1888 Font2D font = fontNameCache.get(mapName);
1889 if (font != null) {
1890 return font;
1891 }
1892 if (FontUtilities.isLogging()) {
1893 FontUtilities.logInfo("Search for font: " + name);
1894 }
1895
1896 // The check below is just so that the bitmap fonts being set by
1897 // AWT and Swing thru the desktop properties do not trigger the
1898 // the load fonts case. The two bitmap fonts are now mapped to
1899 // appropriate equivalents for serif and sansserif.
1900 // Note that the cost of this comparison is only for the first
1901 // call until the map is filled.
1902 if (FontUtilities.isWindows) {
1903 if (lowerCaseName.equals("ms sans serif")) {
1904 name = "sansserif";
1905 } else if (lowerCaseName.equals("ms serif")) {
1906 name = "serif";
1907 }
1908 }
1909
1910 /* This isn't intended to support a client passing in the
1911 * string default, but if a client passes in null for the name
1912 * the java.awt.Font class internally substitutes this name.
1913 * So we need to recognise it here to prevent a loadFonts
1914 * on the unrecognised name. The only potential problem with
1915 * this is it would hide any real font called "default"!
1916 * But that seems like a potential problem we can ignore for now.
1917 */
1918 if (lowerCaseName.equals("default")) {
1919 name = "dialog";
1920 }
1921
1922 /* First see if its a family name. */
1923 FontFamily family = FontFamily.getFamily(name);
1924 if (family != null) {
1925 font = family.getFontWithExactStyleMatch(style);
1926 if (font == null) {
1927 font = findDeferredFont(name, style);
1928 }
1929 if (font == null) {
1930 font = findFontFromPlatform(lowerCaseName, style);
1931 }
1932 if (font == null) {
1933 font = family.getFont(style);
1934 }
1935 if (font == null) {
1936 font = family.getClosestStyle(style);
1937 }
1938 if (font != null) {
1939 fontNameCache.put(mapName, font);
1940 return font;
1941 }
1942 }
1943
1944 /* If it wasn't a family name, it should be a full name of
1945 * either a composite, or a physical font
1946 */
1947 font = fullNameToFont.get(lowerCaseName);
1948 if (font != null) {
1949 /* Check that the requested style matches the matched font's style.
1950 * But also match style automatically if the requested style is
1951 * "plain". This because the existing behaviour is that the fonts
1952 * listed via getAllFonts etc always list their style as PLAIN.
1953 * This does lead to non-commutative behaviours where you might
1954 * start with "Lucida Sans Regular" and ask for a BOLD version
1955 * and get "Lucida Sans DemiBold" but if you ask for the PLAIN
1956 * style of "Lucida Sans DemiBold" you get "Lucida Sans DemiBold".
1957 * This consistent however with what happens if you have a bold
1958 * version of a font and no plain version exists - alg. styling
1959 * doesn't "unbolden" the font.
1960 */
1961 if (font.style == style || style == Font.PLAIN) {
1962 fontNameCache.put(mapName, font);
1963 return font;
1964 } else {
1965 /* If it was a full name like "Lucida Sans Regular", but
1966 * the style requested is "bold", then we want to see if
1967 * there's the appropriate match against another font in
1968 * that family before trying to load all fonts, or applying a
1969 * algorithmic styling
1970 */
1971 family = FontFamily.getFamily(font.getFamilyName(null));
1972 if (family != null) {
1973 Font2D familyFont = family.getFont(style|font.style);
1974 /* We exactly matched the requested style, use it! */
1975 if (familyFont != null) {
1976 fontNameCache.put(mapName, familyFont);
1977 return familyFont;
1978 } else {
1979 /* This next call is designed to support the case
1980 * where bold italic is requested, and if we must
1981 * style, then base it on either bold or italic -
1982 * not on plain!
1983 */
1984 familyFont = family.getClosestStyle(style|font.style);
1985 if (familyFont != null) {
1986 /* The next check is perhaps one
1987 * that shouldn't be done. ie if we get this
1988 * far we have probably as close a match as we
1989 * are going to get. We could load all fonts to
1990 * see if somehow some parts of the family are
1991 * loaded but not all of it.
1992 */
1993 if (familyFont.canDoStyle(style|font.style)) {
1994 fontNameCache.put(mapName, familyFont);
1995 return familyFont;
1996 }
1997 }
1998 }
1999 }
2000 }
2001 }
2002
2003 if (FontUtilities.isWindows) {
2004
2005 font = findFontFromPlatformMap(lowerCaseName, style);
2006 if (FontUtilities.isLogging()) {
2007 FontUtilities.logInfo("findFontFromPlatformMap returned " + font);
2008 }
2009
2010 if (font != null) {
2011 fontNameCache.put(mapName, font);
2012 return font;
2013 }
2014 /* Don't want Windows to return a font from C:\Windows\Fonts
2015 * if someone has installed a font with the same name
2016 * in the JRE.
2017 */
2018 if (deferredFontFiles.size() > 0) {
2019 font = findJREDeferredFont(lowerCaseName, style);
2020 if (font != null) {
2021 fontNameCache.put(mapName, font);
2022 return font;
2023 }
2024 }
2025 font = findFontFromPlatform(lowerCaseName, style);
2026 if (font != null) {
2027 if (FontUtilities.isLogging()) {
2028 FontUtilities.logInfo("Found font via platform API for request:\"" +
2029 name + "\":, style="+style+
2030 " found font: " + font);
2031 }
2032 fontNameCache.put(mapName, font);
2033 return font;
2034 }
2035 }
2036
2037 /* If reach here and no match has been located, then if there are
2038 * uninitialised deferred fonts, load as many of those as needed
2039 * to find the deferred font. If none is found through that
2040 * search continue on.
2041 * There is possibly a minor issue when more than one
2042 * deferred font implements the same font face. Since deferred
2043 * fonts are only those in font configuration files, this is a
2044 * controlled situation, the known case being Solaris euro_fonts
2045 * versions of Arial, Times New Roman, Courier New. However
2046 * the larger font will transparently replace the smaller one
2047 * - see addToFontList() - when it is needed by the composite font.
2048 */
2049 if (deferredFontFiles.size() > 0) {
2050 font = findDeferredFont(name, style);
2051 if (font != null) {
2052 fontNameCache.put(mapName, font);
2053 return font;
2054 }
2055 }
2056
2057 /* We check for application registered fonts before
2058 * explicitly loading all fonts as if necessary the registration
2059 * code will have done so anyway. And we don't want to needlessly
2060 * load the actual files for all fonts.
2061 * Just as for installed fonts we check for family before fullname.
2062 * We do not add these fonts to fontNameCache for the
2063 * app context case which eliminates the overhead of a per context
2064 * cache for these.
2065 */
2066
2067 if (fontsAreRegistered) {
2068 Hashtable<String, FontFamily> familyTable = createdByFamilyName;
2069 Hashtable<String, Font2D> nameTable = createdByFullName;
2070
2071 family = familyTable.get(lowerCaseName);
2072 if (family != null) {
2073 font = family.getFontWithExactStyleMatch(style);
2074 if (font == null) {
2075 font = family.getFont(style);
2076 }
2077 if (font == null) {
2078 font = family.getClosestStyle(style);
2079 }
2080 if (font != null) {
2081 if (fontsAreRegistered) {
2082 fontNameCache.put(mapName, font);
2083 }
2084 return font;
2085 }
2086 }
2087 font = nameTable.get(lowerCaseName);
2088 if (font != null) {
2089 if (fontsAreRegistered) {
2090 fontNameCache.put(mapName, font);
2091 }
2092 return font;
2093 }
2094 }
2095
2096 /* If reach here and no match has been located, then if all fonts
2097 * are not yet loaded, do so, and then recurse.
2098 */
2099 if (!loadedAllFonts) {
2100 if (FontUtilities.isLogging()) {
2101 FontUtilities.logInfo("Load fonts looking for:" + name);
2102 }
2103 loadFonts();
2104 loadedAllFonts = true;
2105 return findFont2D(name, style, fallback);
2106 }
2107
2108 if (!loadedAllFontFiles) {
2109 if (FontUtilities.isLogging()) {
2110 FontUtilities.logInfo("Load font files looking for:" + name);
2111 }
2112 loadFontFiles();
2113 loadedAllFontFiles = true;
2114 return findFont2D(name, style, fallback);
2115 }
2116
2117 /* The primary name is the locale default - ie not US/English but
2118 * whatever is the default in this locale. This is the way it always
2119 * has been but may be surprising to some developers if "Arial Regular"
2120 * were hard-coded in their app and yet "Arial Regular" was not the
2121 * default name. Fortunately for them, as a consequence of the JDK
2122 * supporting returning names and family names for arbitrary locales,
2123 * we also need to support searching all localised names for a match.
2124 * But because this case of the name used to reference a font is not
2125 * the same as the default for this locale is rare, it makes sense to
2126 * search a much shorter list of default locale names and only go to
2127 * a longer list of names in the event that no match was found.
2128 * So add here code which searches localised names too.
2129 * As in 1.4.x this happens only after loading all fonts, which
2130 * is probably the right order.
2131 */
2132 if ((font = findFont2DAllLocales(name, style)) != null) {
2133 fontNameCache.put(mapName, font);
2134 return font;
2135 }
2136
2137 /* Perhaps its a "compatibility" name - timesroman, helvetica,
2138 * or courier, which 1.0 apps used for logical fonts.
2139 * We look for these "late" after a loadFonts as we must not
2140 * hide real fonts of these names.
2141 * Map these appropriately:
2142 * On windows this means according to the rules specified by the
2143 * FontConfiguration : do it only for encoding==Cp1252
2144 *
2145 * REMIND: this is something we plan to remove.
2146 */
2147 if (FontUtilities.isWindows) {
2148 String compatName =
2149 getFontConfiguration().getFallbackFamilyName(name, null);
2150 if (compatName != null) {
2151 font = findFont2D(compatName, style, fallback);
2152 fontNameCache.put(mapName, font);
2153 return font;
2154 }
2155 } else if (lowerCaseName.equals("timesroman")) {
2156 font = findFont2D("serif", style, fallback);
2157 fontNameCache.put(mapName, font);
2158 return font;
2159 } else if (lowerCaseName.equals("helvetica")) {
2160 font = findFont2D("sansserif", style, fallback);
2161 fontNameCache.put(mapName, font);
2162 return font;
2163 } else if (lowerCaseName.equals("courier")) {
2164 font = findFont2D("monospaced", style, fallback);
2165 fontNameCache.put(mapName, font);
2166 return font;
2167 }
2168 if (FontUtilities.isLogging()) {
2169 FontUtilities.logInfo("No font found for:" + name);
2170 }
2171
2172 switch (fallback) {
2173 case PHYSICAL_FALLBACK: return getDefaultPhysicalFont();
2174 case LOGICAL_FALLBACK: return getDefaultLogicalFont(style);
2175 default: return null;
2176 }
2177 }
2178
2179 /*
2180 * Workaround for apps which are dependent on a font metrics bug
2181 * in JDK 1.1. This is an unsupported win32 private setting.
2182 * Left in for a customer - do not remove.
2183 */
2184 public boolean usePlatformFontMetrics() {
2185 return usePlatformFontMetrics;
2186 }
2187
2188 public int getNumFonts() {
2189 return physicalFonts.size()+maxCompFont;
2190 }
2191
2192 private static boolean fontSupportsEncoding(Font font, String encoding) {
2193 return FontUtilities.getFont2D(font).supportsEncoding(encoding);
2194 }
2195
2196 protected abstract String getFontPath(boolean noType1Fonts);
2197
2198 Thread fileCloser = null;
2199 Vector<File> tmpFontFiles = null;
2200
2201 private int createdFontCount = 0;
2202
2203 public Font2D[] createFont2D(File fontFile, int fontFormat, boolean all,
2204 boolean isCopy, CreatedFontTracker tracker)
2205 throws FontFormatException {
2206
2207 List<Font2D> fList = new ArrayList<>();
2208 int cnt = 1;
2209 String fontFilePath = fontFile.getPath();
2210 FileFont font2D = null;
2211 final File fFile = fontFile;
2212 final CreatedFontTracker _tracker = tracker;
2213 boolean weakRefs = false;
2214 int maxStrikes = 0;
2215 synchronized (this) {
2216 if (createdFontCount < maxSoftRefCnt) {
2217 createdFontCount++;
2218 } else {
2219 weakRefs = true;
2220 maxStrikes = 10;
2221 }
2222 }
2223 try {
2224 switch (fontFormat) {
2225 case Font.TRUETYPE_FONT:
2226 font2D = new TrueTypeFont(fontFilePath, null, 0, true);
2227 font2D.setUseWeakRefs(weakRefs, maxStrikes);
2228 fList.add(font2D);
2229 if (!all) {
2230 break;
2231 }
2232 cnt = ((TrueTypeFont)font2D).getFontCount();
2233 int index = 1;
2234 while (index < cnt) {
2235 font2D = new TrueTypeFont(fontFilePath, null, index++, true);
2236 font2D.setUseWeakRefs(weakRefs, maxStrikes);
2237 fList.add(font2D);
2238 }
2239 break;
2240 case Font.TYPE1_FONT:
2241 font2D = new Type1Font(fontFilePath, null, isCopy);
2242 font2D.setUseWeakRefs(weakRefs, maxStrikes);
2243 fList.add(font2D);
2244 break;
2245 default:
2246 throw new FontFormatException("Unrecognised Font Format");
2247 }
2248 } catch (FontFormatException e) {
2249 if (isCopy) {
2250 AccessController.doPrivileged(new PrivilegedAction<Void>() {
2251 public Void run() {
2252 if (_tracker != null) {
2253 _tracker.subBytes((int)fFile.length());
2254 }
2255 fFile.delete();
2256 return null;
2257 }
2258 });
2259 }
2260 throw(e);
2261 }
2262 if (isCopy) {
2263 FileFont.setFileToRemove(fList, fontFile, cnt, tracker);
2264 synchronized (FontManager.class) {
2265
2266 if (tmpFontFiles == null) {
2267 tmpFontFiles = new Vector<File>();
2268 }
2269 tmpFontFiles.add(fontFile);
2270
2271 if (fileCloser == null) {
2272 final Runnable fileCloserRunnable = new Runnable() {
2273 public void run() {
2274 AccessController.doPrivileged(new PrivilegedAction<Void>() {
2275 public Void run() {
2276 for (int i = 0;i < CHANNELPOOLSIZE; i++) {
2277 if (fontFileCache[i] != null) {
2278 try {
2279 fontFileCache[i].close();
2280 } catch (Exception e) {
2281 }
2282 }
2283 }
2284 if (tmpFontFiles != null) {
2285 File[] files = new File[tmpFontFiles.size()];
2286 files = tmpFontFiles.toArray(files);
2287 for (int f=0; f<files.length;f++) {
2288 try {
2289 files[f].delete();
2290 } catch (Exception e) {
2291 }
2292 }
2293 }
2294 return null;
2295 }
2296 });
2297 }
2298 };
2299 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
2300 ThreadGroup rootTG = ThreadGroupUtils.getRootThreadGroup();
2301 fileCloser = new Thread(rootTG, fileCloserRunnable,
2302 "FileCloser", 0, false);
2303 fileCloser.setContextClassLoader(null);
2304 Runtime.getRuntime().addShutdownHook(fileCloser);
2305 return null;
2306 });
2307 }
2308 }
2309 }
2310 return fList.toArray(new Font2D[0]);
2311 }
2312
2313 /* remind: used in X11GraphicsEnvironment and called often enough
2314 * that we ought to obsolete this code
2315 */
2316 public synchronized String getFullNameByFileName(String fileName) {
2317 PhysicalFont[] physFonts = getPhysicalFonts();
2318 for (int i=0;i<physFonts.length;i++) {
2319 if (physFonts[i].platName.equals(fileName)) {
2320 return (physFonts[i].getFontName(null));
2321 }
2322 }
2323 return null;
2324 }
2325
2326 /*
2327 * This is called when font is determined to be invalid/bad.
2328 * It designed to be called (for example) by the font scaler
2329 * when in processing a font file it is discovered to be incorrect.
2330 * This is different than the case where fonts are discovered to
2331 * be incorrect during initial verification, as such fonts are
2332 * never registered.
2333 * Handles to this font held are re-directed to a default font.
2334 * This default may not be an ideal substitute buts it better than
2335 * crashing This code assumes a PhysicalFont parameter as it doesn't
2336 * make sense for a Composite to be "bad".
2337 */
2338 public synchronized void deRegisterBadFont(Font2D font2D) {
2339 if (!(font2D instanceof PhysicalFont)) {
2340 /* We should never reach here, but just in case */
2341 return;
2342 } else {
2343 if (FontUtilities.isLogging()) {
2344 FontUtilities.logSevere("Deregister bad font: " + font2D);
2345 }
2346 replaceFont((PhysicalFont)font2D, getDefaultPhysicalFont());
2347 }
2348 }
2349
2350 /*
2351 * This encapsulates all the work that needs to be done when a
2352 * Font2D is replaced by a different Font2D.
2353 */
2354 public synchronized void replaceFont(PhysicalFont oldFont,
2355 PhysicalFont newFont) {
2356
2357 if (oldFont.handle.font2D != oldFont) {
2358 /* already done */
2359 return;
2360 }
2361
2362 /* If we try to replace the font with itself, that won't work,
2363 * so pick any alternative physical font
2364 */
2365 if (oldFont == newFont) {
2366 if (FontUtilities.isLogging()) {
2367 FontUtilities.logSevere("Can't replace bad font with itself " + oldFont);
2368 }
2369 PhysicalFont[] physFonts = getPhysicalFonts();
2370 for (int i=0; i<physFonts.length;i++) {
2371 if (physFonts[i] != newFont) {
2372 newFont = physFonts[i];
2373 break;
2374 }
2375 }
2376 if (oldFont == newFont) {
2377 if (FontUtilities.isLogging()) {
2378 FontUtilities.logSevere("This is bad. No good physicalFonts found.");
2379 }
2380 return;
2381 }
2382 }
2383
2384 /* eliminate references to this font, so it won't be located
2385 * by future callers, and will be eligible for GC when all
2386 * references are removed
2387 */
2388 oldFont.handle.font2D = newFont;
2389 physicalFonts.remove(oldFont.fullName);
2390 fullNameToFont.remove(oldFont.fullName.toLowerCase(Locale.ENGLISH));
2391 FontFamily.remove(oldFont);
2392 if (localeFullNamesToFont != null) {
2393 Map.Entry<?, ?>[] mapEntries = localeFullNamesToFont.entrySet().
2394 toArray(new Map.Entry<?, ?>[0]);
2395 /* Should I be replacing these, or just I just remove
2396 * the names from the map?
2397 */
2398 for (int i=0; i<mapEntries.length;i++) {
2399 if (mapEntries[i].getValue() == oldFont) {
2400 try {
2401 @SuppressWarnings("unchecked")
2402 Map.Entry<String, PhysicalFont> tmp = (Map.Entry<String, PhysicalFont>)mapEntries[i];
2403 tmp.setValue(newFont);
2404 } catch (Exception e) {
2405 /* some maps don't support this operation.
2406 * In this case just give up and remove the entry.
2407 */
2408 localeFullNamesToFont.remove(mapEntries[i].getKey());
2409 }
2410 }
2411 }
2412 }
2413
2414 for (int i=0; i<maxCompFont; i++) {
2415 /* Deferred initialization of composites shouldn't be
2416 * a problem for this case, since a font must have been
2417 * initialised to be discovered to be bad.
2418 * Some JRE composites on Solaris use two versions of the same
2419 * font. The replaced font isn't bad, just "smaller" so there's
2420 * no need to make the slot point to the new font.
2421 * Since composites have a direct reference to the Font2D (not
2422 * via a handle) making this substitution is not safe and could
2423 * cause an additional problem and so this substitution is
2424 * warranted only when a font is truly "bad" and could cause
2425 * a crash. So we now replace it only if its being substituted
2426 * with some font other than a fontconfig rank font
2427 * Since in practice a substitution will have the same rank
2428 * this may never happen, but the code is safer even if its
2429 * also now a no-op.
2430 * The only obvious "glitch" from this stems from the current
2431 * implementation that when asked for the number of glyphs in a
2432 * composite it lies and returns the number in slot 0 because
2433 * composite glyphs aren't contiguous. Since we live with that
2434 * we can live with the glitch that depending on how it was
2435 * initialised a composite may return different values for this.
2436 * Fixing the issues with composite glyph ids is tricky as
2437 * there are exclusion ranges and unlike other fonts even the
2438 * true "numGlyphs" isn't a contiguous range. Likely the only
2439 * solution is an API that returns an array of glyph ranges
2440 * which takes precedence over the existing API. That might
2441 * also need to address excluding ranges which represent a
2442 * code point supported by an earlier component.
2443 */
2444 if (newFont.getRank() > Font2D.FONT_CONFIG_RANK) {
2445 compFonts[i].replaceComponentFont(oldFont, newFont);
2446 }
2447 }
2448 }
2449
2450 private synchronized void loadLocaleNames() {
2451 if (localeFullNamesToFont != null) {
2452 return;
2453 }
2454 localeFullNamesToFont = new HashMap<>();
2455 Font2D[] fonts = getRegisteredFonts();
2456 for (int i=0; i<fonts.length; i++) {
2457 if (fonts[i] instanceof TrueTypeFont) {
2458 TrueTypeFont ttf = (TrueTypeFont)fonts[i];
2459 String[] fullNames = ttf.getAllFullNames();
2460 for (int n=0; n<fullNames.length; n++) {
2461 localeFullNamesToFont.put(fullNames[n], ttf);
2462 }
2463 FontFamily family = FontFamily.getFamily(ttf.familyName);
2464 if (family != null) {
2465 FontFamily.addLocaleNames(family, ttf.getAllFamilyNames());
2466 }
2467 }
2468 }
2469 }
2470
2471 /* This replicate the core logic of findFont2D but operates on
2472 * all the locale names. This hasn't been merged into findFont2D to
2473 * keep the logic simpler and reduce overhead, since this case is
2474 * almost never used. The main case in which it is called is when
2475 * a bogus font name is used and we need to check all possible names
2476 * before returning the default case.
2477 */
2478 private Font2D findFont2DAllLocales(String name, int style) {
2479 if (FontUtilities.isLogging()) {
2480 FontUtilities.logInfo("Searching localised font names for:" + name);
2481 }
2482
2483 /* If reach here and no match has been located, then if we have
2484 * not yet built the map of localeFullNamesToFont for TT fonts, do so
2485 * now. This method must be called after all fonts have been loaded.
2486 */
2487 if (localeFullNamesToFont == null) {
2488 loadLocaleNames();
2489 }
2490 String lowerCaseName = name.toLowerCase();
2491 Font2D font = null;
2492
2493 /* First see if its a family name. */
2494 FontFamily family = FontFamily.getLocaleFamily(lowerCaseName);
2495 if (family != null) {
2496 font = family.getFont(style);
2497 if (font == null) {
2498 font = family.getClosestStyle(style);
2499 }
2500 if (font != null) {
2501 return font;
2502 }
2503 }
2504
2505 /* If it wasn't a family name, it should be a full name. */
2506 synchronized (this) {
2507 font = localeFullNamesToFont.get(name);
2508 }
2509 if (font != null) {
2510 if (font.style == style || style == Font.PLAIN) {
2511 return font;
2512 } else {
2513 family = FontFamily.getFamily(font.getFamilyName(null));
2514 if (family != null) {
2515 Font2D familyFont = family.getFont(style);
2516 /* We exactly matched the requested style, use it! */
2517 if (familyFont != null) {
2518 return familyFont;
2519 } else {
2520 familyFont = family.getClosestStyle(style);
2521 if (familyFont != null) {
2522 /* The next check is perhaps one
2523 * that shouldn't be done. ie if we get this
2524 * far we have probably as close a match as we
2525 * are going to get. We could load all fonts to
2526 * see if somehow some parts of the family are
2527 * loaded but not all of it.
2528 * This check is commented out for now.
2529 */
2530 if (!familyFont.canDoStyle(style)) {
2531 familyFont = null;
2532 }
2533 return familyFont;
2534 }
2535 }
2536 }
2537 }
2538 }
2539 return font;
2540 }
2541
2542 /* Supporting "alternate" composite fonts on 2D graphics objects
2543 * is accessed by the application by calling methods on the local
2544 * GraphicsEnvironment. The overall implementation is described
2545 * in one place, here, since otherwise the implementation is spread
2546 * around it may be difficult to track.
2547 * The methods below call into SunGraphicsEnvironment which creates a
2548 * new FontConfiguration instance. The FontConfiguration class,
2549 * and its platform sub-classes are updated to take parameters requesting
2550 * these behaviours. This is then used to create new composite font
2551 * instances. Since this calls the initCompositeFont method in
2552 * SunGraphicsEnvironment it performs the same initialization as is
2553 * performed normally. There may be some duplication of effort, but
2554 * that code is already written to be able to perform properly if called
2555 * to duplicate work. The main difference is that if we detect we are
2556 * running in an applet/browser/Java plugin environment these new fonts
2557 * are not placed in the "default" maps but into an AppContext instance.
2558 * The font lookup mechanism in java.awt.Font.getFont2D() is also updated
2559 * so that look-up for composite fonts will in that case always
2560 * do a lookup rather than returning a cached result.
2561 * This is inefficient but necessary else singleton java.awt.Font
2562 * instances would not retrieve the correct Font2D for the appcontext.
2563 * sun.font.FontManager.findFont2D is also updated to that it uses
2564 * a name map cache specific to that appcontext.
2565 *
2566 * Getting an AppContext is expensive, so there is a global variable
2567 * that records whether these methods have ever been called and can
2568 * avoid the expense for almost all applications. Once the correct
2569 * CompositeFont is associated with the Font, everything should work
2570 * through existing mechanisms.
2571 * A special case is that GraphicsEnvironment.getAllFonts() must
2572 * return an AppContext specific list.
2573 *
2574 * Calling the methods below is "heavyweight" but it is expected that
2575 * these methods will be called very rarely.
2576 *
2577 * If _usingAlternateComposites is true, we are not in an "applet"
2578 * environment and the (single) application has selected
2579 * an alternate composite font behaviour.
2580 *
2581 * - Printing: The implementation delegates logical fonts to an AWT
2582 * mechanism which cannot use these alternate configurations.
2583 * We can detect that alternate fonts are in use and back-off to 2D, but
2584 * that uses outlines. Much of this can be fixed with additional work
2585 * but that may have to wait. The results should be correct, just not
2586 * optimal.
2587 */
2588 private boolean _usingAlternateComposites = false;
2589
2590 private static boolean gAltJAFont = false;
2591 private boolean gLocalePref = false;
2592 private boolean gPropPref = false;
2593
2594 /* Its used by the FontMetrics caching code which in such
2595 * a case cannot retrieve a cached metrics solely on the basis of
2596 * the Font.equals() method since it needs to also check if the Font2D
2597 * is the same.
2598 * We also use non-standard composites for Swing native L&F fonts on
2599 * Windows. In that case the policy is that the metrics reported are
2600 * based solely on the physical font in the first slot which is the
2601 * visible java.awt.Font. So in that case the metrics cache which tests
2602 * the Font does what we want. In the near future when we expand the GTK
2603 * logical font definitions we may need to revisit this if GTK reports
2604 * combined metrics instead. For now though this test can be simple.
2605 */
2606 public boolean usingAlternateCompositeFonts() {
2607 return _usingAlternateComposites;
2608 }
2609
2610 /* Modifies the behaviour of a subsequent call to preferLocaleFonts()
2611 * to use Mincho instead of Gothic for dialoginput in JA locales
2612 * on windows. Not needed on other platforms.
2613 */
2614 public synchronized void useAlternateFontforJALocales() {
2615 if (FontUtilities.isLogging()) {
2616 FontUtilities.logInfo("Entered useAlternateFontforJALocales().");
2617 }
2618
2619 if (!FontUtilities.isWindows) {
2620 return;
2621 }
2622 gAltJAFont = true;
2623 }
2624
2625 public boolean usingAlternateFontforJALocales() {
2626 return gAltJAFont;
2627 }
2628
2629 public synchronized void preferLocaleFonts() {
2630 if (FontUtilities.isLogging()) {
2631 FontUtilities.logInfo("Entered preferLocaleFonts().");
2632 }
2633
2634 /* Test if re-ordering will have any effect */
2635 if (!FontConfiguration.willReorderForStartupLocale()) {
2636 return;
2637 }
2638 if (gLocalePref == true) {
2639 return;
2640 }
2641 gLocalePref = true;
2642 createCompositeFonts(fontNameCache, gLocalePref, gPropPref);
2643 _usingAlternateComposites = true;
2644 }
2645
2646 public synchronized void preferProportionalFonts() {
2647 if (FontUtilities.isLogging()) {
2648 FontUtilities.logInfo("Entered preferProportionalFonts().");
2649 }
2650
2651 /* If no proportional fonts are configured, there's no need
2652 * to take any action.
2653 */
2654 if (!FontConfiguration.hasMonoToPropMap()) {
2655 return;
2656 }
2657 if (gPropPref == true) {
2658 return;
2659 }
2660 gPropPref = true;
2661 createCompositeFonts(fontNameCache, gLocalePref, gPropPref);
2662 _usingAlternateComposites = true;
2663 }
2664
2665 private static HashSet<String> installedNames = null;
2666 private static HashSet<String> getInstalledNames() {
2667 if (installedNames == null) {
2668 Locale l = getSystemStartupLocale();
2669 SunFontManager fontManager = SunFontManager.getInstance();
2670 String[] installedFamilies =
2671 fontManager.getInstalledFontFamilyNames(l);
2672 Font[] installedFonts = fontManager.getAllInstalledFonts();
2673 HashSet<String> names = new HashSet<>();
2674 for (int i=0; i<installedFamilies.length; i++) {
2675 names.add(installedFamilies[i].toLowerCase(l));
2676 }
2677 for (int i=0; i<installedFonts.length; i++) {
2678 names.add(installedFonts[i].getFontName(l).toLowerCase(l));
2679 }
2680 installedNames = names;
2681 }
2682 return installedNames;
2683 }
2684
2685 private static final Object regFamilyLock = new Object();
2686 private Hashtable<String,FontFamily> createdByFamilyName;
2687 private Hashtable<String,Font2D> createdByFullName;
2688 private boolean fontsAreRegistered = false;
2689
2690 public boolean registerFont(Font font) {
2691 /* This method should not be called with "null".
2692 * It is the caller's responsibility to ensure that.
2693 */
2694 if (font == null) {
2695 return false;
2696 }
2697
2698 /* Initialise these objects only once we start to use this API */
2699 synchronized (regFamilyLock) {
2700 if (createdByFamilyName == null) {
2701 createdByFamilyName = new Hashtable<String,FontFamily>();
2702 createdByFullName = new Hashtable<String,Font2D>();
2703 }
2704 }
2705
2706 if (! FontAccess.getFontAccess().isCreatedFont(font)) {
2707 return false;
2708 }
2709 /* We want to ensure that this font cannot override existing
2710 * installed fonts. Check these conditions :
2711 * - family name is not that of an installed font
2712 * - full name is not that of an installed font
2713 * - family name is not the same as the full name of an installed font
2714 * - full name is not the same as the family name of an installed font
2715 * The last two of these may initially look odd but the reason is
2716 * that (unfortunately) Font constructors do not distinuguish these.
2717 * An extreme example of such a problem would be a font which has
2718 * family name "Dialog.Plain" and full name of "Dialog".
2719 * The one arguably overly stringent restriction here is that if an
2720 * application wants to supply a new member of an existing family
2721 * It will get rejected. But since the JRE can perform synthetic
2722 * styling in many cases its not necessary.
2723 * We don't apply the same logic to registered fonts. If apps want
2724 * to do this lets assume they have a reason. It won't cause problems
2725 * except for themselves.
2726 */
2727 HashSet<String> names = getInstalledNames();
2728 Locale l = getSystemStartupLocale();
2729 String familyName = font.getFamily(l).toLowerCase();
2730 String fullName = font.getFontName(l).toLowerCase();
2731 if (names.contains(familyName) || names.contains(fullName)) {
2732 return false;
2733 }
2734
2735 /* Checks passed, now register the font */
2736 Hashtable<String, FontFamily> familyTable = createdByFamilyName;
2737 Hashtable<String, Font2D> fullNameTable = createdByFullName;
2738 fontsAreRegistered = true;
2739
2740 /* Create the FontFamily and add font to the tables */
2741 Font2D font2D = FontUtilities.getFont2D(font);
2742 int style = font2D.getStyle();
2743 FontFamily family = familyTable.get(familyName);
2744 if (family == null) {
2745 family = new FontFamily(font.getFamily(l));
2746 familyTable.put(familyName, family);
2747 }
2748 /* Remove name cache entries if not using app contexts.
2749 * To accommodate a case where code may have registered first a plain
2750 * family member and then used it and is now registering a bold family
2751 * member, we need to remove all members of the family, so that the
2752 * new style can get picked up rather than continuing to synthesise.
2753 */
2754 if (fontsAreRegistered) {
2755 removeFromCache(family.getFont(Font.PLAIN));
2756 removeFromCache(family.getFont(Font.BOLD));
2757 removeFromCache(family.getFont(Font.ITALIC));
2758 removeFromCache(family.getFont(Font.BOLD|Font.ITALIC));
2759 removeFromCache(fullNameTable.get(fullName));
2760 }
2761 family.setFont(font2D, style);
2762 fullNameTable.put(fullName, font2D);
2763 return true;
2764 }
2765
2766 /* Remove from the name cache all references to the Font2D */
2767 private void removeFromCache(Font2D font) {
2768 if (font == null) {
2769 return;
2770 }
2771 String[] keys = fontNameCache.keySet().toArray(STR_ARRAY);
2772 for (int k=0; k<keys.length;k++) {
2773 if (fontNameCache.get(keys[k]) == font) {
2774 fontNameCache.remove(keys[k]);
2775 }
2776 }
2777 }
2778
2779 // It may look odd to use TreeMap but its more convenient to the caller.
2780 public TreeMap<String, String> getCreatedFontFamilyNames() {
2781
2782 Hashtable<String,FontFamily> familyTable;
2783 if (fontsAreRegistered) {
2784 familyTable = createdByFamilyName;
2785 } else {
2786 return null;
2787 }
2788
2789 Locale l = getSystemStartupLocale();
2790 synchronized (familyTable) {
2791 TreeMap<String, String> map = new TreeMap<String, String>();
2792 for (FontFamily f : familyTable.values()) {
2793 Font2D font2D = f.getFont(Font.PLAIN);
2794 if (font2D == null) {
2795 font2D = f.getClosestStyle(Font.PLAIN);
2796 }
2797 String name = font2D.getFamilyName(l);
2798 map.put(name.toLowerCase(l), name);
2799 }
2800 return map;
2801 }
2802 }
2803
2804 public Font[] getCreatedFonts() {
2805
2806 Hashtable<String,Font2D> nameTable;
2807 if (fontsAreRegistered) {
2808 nameTable = createdByFullName;
2809 } else {
2810 return null;
2811 }
2812
2813 Locale l = getSystemStartupLocale();
2814 synchronized (nameTable) {
2815 Font[] fonts = new Font[nameTable.size()];
2816 int i=0;
2817 for (Font2D font2D : nameTable.values()) {
2818 fonts[i++] = new Font(font2D.getFontName(l), Font.PLAIN, 1);
2819 }
2820 return fonts;
2821 }
2822 }
2823
2824
2825 protected String[] getPlatformFontDirs(boolean noType1Fonts) {
2826
2827 /* First check if we already initialised path dirs */
2828 if (pathDirs != null) {
2829 return pathDirs;
2830 }
2831
2832 String path = getPlatformFontPath(noType1Fonts);
2833 StringTokenizer parser =
2834 new StringTokenizer(path, File.pathSeparator);
2835 ArrayList<String> pathList = new ArrayList<>();
2836 try {
2837 while (parser.hasMoreTokens()) {
2838 pathList.add(parser.nextToken());
2839 }
2840 } catch (NoSuchElementException e) {
2841 }
2842 pathDirs = pathList.toArray(new String[0]);
2843 return pathDirs;
2844 }
2845
2846 /**
2847 * Returns an array of two strings. The first element is the
2848 * name of the font. The second element is the file name.
2849 */
2850 protected abstract String[] getDefaultPlatformFont();
2851
2852 // Begin: Refactored from SunGraphicsEnviroment.
2853
2854 /*
2855 * helper function for registerFonts
2856 */
2857 private void addDirFonts(String dirName, File dirFile,
2858 FilenameFilter filter,
2859 int fontFormat, boolean useJavaRasterizer,
2860 int fontRank,
2861 boolean defer, boolean resolveSymLinks) {
2862 String[] ls = dirFile.list(filter);
2863 if (ls == null || ls.length == 0) {
2864 return;
2865 }
2866 String[] fontNames = new String[ls.length];
2867 String[][] nativeNames = new String[ls.length][];
2868 int fontCount = 0;
2869
2870 for (int i=0; i < ls.length; i++ ) {
2871 File theFile = new File(dirFile, ls[i]);
2872 String fullName = null;
2873 if (resolveSymLinks) {
2874 try {
2875 fullName = theFile.getCanonicalPath();
2876 } catch (IOException e) {
2877 }
2878 }
2879 if (fullName == null) {
2880 fullName = dirName + File.separator + ls[i];
2881 }
2882
2883 // REMIND: case compare depends on platform
2884 if (registeredFontFiles.contains(fullName)) {
2885 continue;
2886 }
2887
2888 if (badFonts != null && badFonts.contains(fullName)) {
2889 if (FontUtilities.debugFonts()) {
2890 FontUtilities.logWarning("skip bad font " + fullName);
2891 }
2892 continue; // skip this font file.
2893 }
2894
2895 registeredFontFiles.add(fullName);
2896
2897 if (FontUtilities.debugFonts()
2898 && FontUtilities.getLogger().isLoggable(PlatformLogger.Level.INFO)) {
2899 String message = "Registering font " + fullName;
2900 String[] natNames = getNativeNames(fullName, null);
2901 if (natNames == null) {
2902 message += " with no native name";
2903 } else {
2904 message += " with native name(s) " + natNames[0];
2905 for (int nn = 1; nn < natNames.length; nn++) {
2906 message += ", " + natNames[nn];
2907 }
2908 }
2909 FontUtilities.logInfo(message);
2910 }
2911 fontNames[fontCount] = fullName;
2912 nativeNames[fontCount++] = getNativeNames(fullName, null);
2913 }
2914 registerFonts(fontNames, nativeNames, fontCount, fontFormat,
2915 useJavaRasterizer, fontRank, defer);
2916 return;
2917 }
2918
2919 protected String[] getNativeNames(String fontFileName,
2920 String platformName) {
2921 return null;
2922 }
2923
2924 /**
2925 * Returns a file name for the physical font represented by this platform
2926 * font name. The default implementation tries to obtain the file name
2927 * from the font configuration.
2928 * Subclasses may override to provide information from other sources.
2929 */
2930 protected String getFileNameFromPlatformName(String platformFontName) {
2931 return fontConfig.getFileNameFromPlatformName(platformFontName);
2932 }
2933
2934 /**
2935 * Return the default font configuration.
2936 */
2937 public FontConfiguration getFontConfiguration() {
2938 return fontConfig;
2939 }
2940
2941 /* A call to this method should be followed by a call to
2942 * registerFontDirs(..)
2943 */
2944 public String getPlatformFontPath(boolean noType1Font) {
2945 if (fontPath == null) {
2946 fontPath = getFontPath(noType1Font);
2947 }
2948 return fontPath;
2949 }
2950
2951 protected void loadFonts() {
2952 if (discoveredAllFonts) {
2953 return;
2954 }
2955 /* Use lock specific to the font system */
2956 synchronized (this) {
2957 if (FontUtilities.debugFonts()) {
2958 Thread.dumpStack();
2959 FontUtilities.logInfo("SunGraphicsEnvironment.loadFonts() called");
2960 }
2961 initialiseDeferredFonts();
2962
2963 AccessController.doPrivileged(new PrivilegedAction<Void>() {
2964 public Void run() {
2965 if (fontPath == null) {
2966 fontPath = getPlatformFontPath(noType1Font);
2967 registerFontDirs(fontPath);
2968 }
2969 if (fontPath != null) {
2970 // this will find all fonts including those already
2971 // registered. But we have checks in place to prevent
2972 // double registration.
2973 if (! gotFontsFromPlatform()) {
2974 registerFontsOnPath(fontPath, false,
2975 Font2D.UNKNOWN_RANK,
2976 false, true);
2977 loadedAllFontFiles = true;
2978 }
2979 }
2980 registerOtherFontFiles(registeredFontFiles);
2981 discoveredAllFonts = true;
2982 return null;
2983 }
2984 });
2985 }
2986 }
2987
2988 protected void registerFontDirs(String pathName) {
2989 return;
2990 }
2991
2992 private void registerFontsOnPath(String pathName,
2993 boolean useJavaRasterizer, int fontRank,
2994 boolean defer, boolean resolveSymLinks) {
2995
2996 StringTokenizer parser = new StringTokenizer(pathName,
2997 File.pathSeparator);
2998 try {
2999 while (parser.hasMoreTokens()) {
3000 registerFontsInDir(parser.nextToken(),
3001 useJavaRasterizer, fontRank,
3002 defer, resolveSymLinks);
3003 }
3004 } catch (NoSuchElementException e) {
3005 }
3006 }
3007
3008 /* Called to register fall back fonts */
3009 public void registerFontsInDir(String dirName) {
3010 registerFontsInDir(dirName, true, Font2D.JRE_RANK, true, false);
3011 }
3012
3013 // MACOSX begin -- need to access this in subclass
3014 protected void registerFontsInDir(String dirName, boolean useJavaRasterizer,
3015 // MACOSX end
3016 int fontRank,
3017 boolean defer, boolean resolveSymLinks) {
3018 File pathFile = new File(dirName);
3019 addDirFonts(dirName, pathFile, ttFilter,
3020 FONTFORMAT_TRUETYPE, useJavaRasterizer,
3021 fontRank==Font2D.UNKNOWN_RANK ?
3022 Font2D.TTF_RANK : fontRank,
3023 defer, resolveSymLinks);
3024 addDirFonts(dirName, pathFile, t1Filter,
3025 FONTFORMAT_TYPE1, useJavaRasterizer,
3026 fontRank==Font2D.UNKNOWN_RANK ?
3027 Font2D.TYPE1_RANK : fontRank,
3028 defer, resolveSymLinks);
3029 }
3030
3031 protected void registerFontDir(String path) {
3032 }
3033
3034 /**
3035 * Returns file name for default font, either absolute
3036 * or relative as needed by registerFontFile.
3037 */
3038 public synchronized String getDefaultFontFile() {
3039 return defaultFontFileName;
3040 }
3041
3042 /**
3043 * Whether registerFontFile expects absolute or relative
3044 * font file names.
3045 */
3046 protected boolean useAbsoluteFontFileNames() {
3047 return true;
3048 }
3049
3050 /**
3051 * Creates this environment's FontConfiguration.
3052 */
3053 protected abstract FontConfiguration createFontConfiguration();
3054
3055 public abstract FontConfiguration
3056 createFontConfiguration(boolean preferLocaleFonts,
3057 boolean preferPropFonts);
3058
3059 /**
3060 * Returns face name for default font, or null if
3061 * no face names are used for CompositeFontDescriptors
3062 * for this platform.
3063 */
3064 public synchronized String getDefaultFontFaceName() {
3065 return defaultFontName;
3066 }
3067
3068 public void loadFontFiles() {
3069 loadFonts();
3070 if (loadedAllFontFiles) {
3071 return;
3072 }
3073 /* Use lock specific to the font system */
3074 synchronized (this) {
3075 if (FontUtilities.debugFonts()) {
3076 Thread.dumpStack();
3077 FontUtilities.logInfo("loadAllFontFiles() called");
3078 }
3079 AccessController.doPrivileged(new PrivilegedAction<Void>() {
3080 public Void run() {
3081 if (fontPath == null) {
3082 fontPath = getPlatformFontPath(noType1Font);
3083 }
3084 if (fontPath != null) {
3085 // this will find all fonts including those already
3086 // registered. But we have checks in place to prevent
3087 // double registration.
3088 registerFontsOnPath(fontPath, false,
3089 Font2D.UNKNOWN_RANK,
3090 false, true);
3091 }
3092 loadedAllFontFiles = true;
3093 return null;
3094 }
3095 });
3096 }
3097 }
3098
3099 /*
3100 * This method asks the font configuration API for all platform names
3101 * used as components of composite/logical fonts and iterates over these
3102 * looking up their corresponding file name and registers these fonts.
3103 * It also ensures that the fonts are accessible via platform APIs.
3104 * The composites themselves are then registered.
3105 */
3106 private void
3107 initCompositeFonts(FontConfiguration fontConfig,
3108 ConcurrentHashMap<String, Font2D> altNameCache) {
3109 if (FontUtilities.isLogging()) {
3110 FontUtilities.logInfo("Initialising composite fonts");
3111 }
3112
3113 int numCoreFonts = fontConfig.getNumberCoreFonts();
3114 String[] fcFonts = fontConfig.getPlatformFontNames();
3115 for (int f=0; f<fcFonts.length; f++) {
3116 String platformFontName = fcFonts[f];
3117 String fontFileName =
3118 getFileNameFromPlatformName(platformFontName);
3119 String[] nativeNames = null;
3120 if (fontFileName == null
3121 || fontFileName.equals(platformFontName)) {
3122 /* No file located, so register using the platform name,
3123 * i.e. as a native font.
3124 */
3125 fontFileName = platformFontName;
3126 } else {
3127 if (f < numCoreFonts) {
3128 /* If platform APIs also need to access the font, add it
3129 * to a set to be registered with the platform too.
3130 * This may be used to add the parent directory to the X11
3131 * font path if its not already there. See the docs for the
3132 * subclass implementation.
3133 * This is now mainly for the benefit of X11-based AWT
3134 * But for historical reasons, 2D initialisation code
3135 * makes these calls.
3136 * If the fontconfiguration file is properly set up
3137 * so that all fonts are mapped to files and all their
3138 * appropriate directories are specified, then this
3139 * method will be low cost as it will return after
3140 * a test that finds a null lookup map.
3141 */
3142 addFontToPlatformFontPath(platformFontName);
3143 }
3144 nativeNames = getNativeNames(fontFileName, platformFontName);
3145 }
3146 /* Uncomment these two lines to "generate" the XLFD->filename
3147 * mappings needed to speed start-up on Solaris.
3148 * Augment this with the appendedpathname and the mappings
3149 * for native (F3) fonts
3150 */
3151 //String platName = platformFontName.replaceAll(" ", "_");
3152 //System.out.println("filename."+platName+"="+fontFileName);
3153 registerFontFile(fontFileName, nativeNames,
3154 Font2D.FONT_CONFIG_RANK, true);
3155
3156
3157 }
3158 /* This registers accumulated paths from the calls to
3159 * addFontToPlatformFontPath(..) and any specified by
3160 * the font configuration. Rather than registering
3161 * the fonts it puts them in a place and form suitable for
3162 * the Toolkit to pick up and use if a toolkit is initialised,
3163 * and if it uses X11 fonts.
3164 */
3165 registerPlatformFontsUsedByFontConfiguration();
3166
3167 CompositeFontDescriptor[] compositeFontInfo
3168 = fontConfig.get2DCompositeFontInfo();
3169 for (int i = 0; i < compositeFontInfo.length; i++) {
3170 CompositeFontDescriptor descriptor = compositeFontInfo[i];
3171 String[] componentFileNames = descriptor.getComponentFileNames();
3172 String[] componentFaceNames = descriptor.getComponentFaceNames();
3173
3174 /* It would be better eventually to handle this in the
3175 * FontConfiguration code which should also remove duplicate slots
3176 */
3177 if (missingFontFiles != null) {
3178 for (int ii=0; ii<componentFileNames.length; ii++) {
3179 if (missingFontFiles.contains(componentFileNames[ii])) {
3180 componentFileNames[ii] = getDefaultFontFile();
3181 componentFaceNames[ii] = getDefaultFontFaceName();
3182 }
3183 }
3184 }
3185
3186 /* FontConfiguration needs to convey how many fonts it has added
3187 * as fallback component fonts which should not affect metrics.
3188 * The core component count will be the number of metrics slots.
3189 * This does not preclude other mechanisms for adding
3190 * fall back component fonts to the composite.
3191 */
3192 if (altNameCache != null) {
3193 SunFontManager.registerCompositeFont(
3194 descriptor.getFaceName(),
3195 componentFileNames, componentFaceNames,
3196 descriptor.getCoreComponentCount(),
3197 descriptor.getExclusionRanges(),
3198 descriptor.getExclusionRangeLimits(),
3199 true,
3200 altNameCache);
3201 } else {
3202 registerCompositeFont(descriptor.getFaceName(),
3203 componentFileNames, componentFaceNames,
3204 descriptor.getCoreComponentCount(),
3205 descriptor.getExclusionRanges(),
3206 descriptor.getExclusionRangeLimits(),
3207 true);
3208 }
3209 if (FontUtilities.debugFonts()) {
3210 FontUtilities.logInfo("registered " + descriptor.getFaceName());
3211 }
3212 }
3213 }
3214
3215 /**
3216 * Notifies graphics environment that the logical font configuration
3217 * uses the given platform font name. The graphics environment may
3218 * use this for platform specific initialization.
3219 */
3220 protected void addFontToPlatformFontPath(String platformFontName) {
3221 }
3222
3223 protected void registerFontFile(String fontFileName, String[] nativeNames,
3224 int fontRank, boolean defer) {
3225 // REMIND: case compare depends on platform
3226 if (registeredFontFiles.contains(fontFileName)) {
3227 return;
3228 }
3229 int fontFormat;
3230 if (ttFilter.accept(null, fontFileName)) {
3231 fontFormat = FONTFORMAT_TRUETYPE;
3232 } else if (t1Filter.accept(null, fontFileName)) {
3233 fontFormat = FONTFORMAT_TYPE1;
3234 } else {
3235 fontFormat = FONTFORMAT_NATIVE;
3236 }
3237 registeredFontFiles.add(fontFileName);
3238 if (defer) {
3239 registerDeferredFont(fontFileName, fontFileName, nativeNames,
3240 fontFormat, false, fontRank);
3241 } else {
3242 registerFontFile(fontFileName, nativeNames, fontFormat, false,
3243 fontRank);
3244 }
3245 }
3246
3247 protected void registerPlatformFontsUsedByFontConfiguration() {
3248 }
3249
3250 /*
3251 * A GE may verify whether a font file used in a fontconfiguration
3252 * exists. If it doesn't then either we may substitute the default
3253 * font, or perhaps elide it altogether from the composite font.
3254 * This makes some sense on windows where the font file is only
3255 * likely to be in one place. But on other OSes, eg Linux, the file
3256 * can move around depending. So there we probably don't want to assume
3257 * its missing and so won't add it to this list.
3258 * If this list - missingFontFiles - is non-null then the composite
3259 * font initialisation logic tests to see if a font file is in that
3260 * set.
3261 * Only one thread should be able to add to this set so we don't
3262 * synchronize.
3263 */
3264 protected void addToMissingFontFileList(String fileName) {
3265 if (missingFontFiles == null) {
3266 missingFontFiles = new HashSet<>();
3267 }
3268 missingFontFiles.add(fileName);
3269 }
3270
3271 /*
3272 * This is for use only within getAllFonts().
3273 * Fonts listed in the fontconfig files for windows were all
3274 * on the "deferred" initialisation list. They were registered
3275 * either in the course of the application, or in the call to
3276 * loadFonts() within getAllFonts(). The fontconfig file specifies
3277 * the names of the fonts using the English names. If there's a
3278 * different name in the execution locale, then the platform will
3279 * report that, and we will construct the font with both names, and
3280 * thereby enumerate it twice. This happens for Japanese fonts listed
3281 * in the windows fontconfig, when run in the JA locale. The solution
3282 * is to rely (in this case) on the platform's font->file mapping to
3283 * determine that this name corresponds to a file we already registered.
3284 * This works because
3285 * - we know when we get here all deferred fonts are already initialised
3286 * - when we register a font file, we register all fonts in it.
3287 * - we know the fontconfig fonts are all in the windows registry
3288 */
3289 private boolean isNameForRegisteredFile(String fontName) {
3290 String fileName = getFileNameForFontName(fontName);
3291 if (fileName == null) {
3292 return false;
3293 }
3294 return registeredFontFiles.contains(fileName);
3295 }
3296
3297 /*
3298 * This invocation is not in a privileged block because
3299 * all privileged operations (reading files and properties)
3300 * was conducted on the creation of the GE
3301 */
3302 public void
3303 createCompositeFonts(ConcurrentHashMap<String, Font2D> altNameCache,
3304 boolean preferLocale,
3305 boolean preferProportional) {
3306
3307 FontConfiguration fontConfig =
3308 createFontConfiguration(preferLocale, preferProportional);
3309 initCompositeFonts(fontConfig, altNameCache);
3310 }
3311
3312 /**
3313 * Returns all fonts installed in this environment.
3314 */
3315 public Font[] getAllInstalledFonts() {
3316 if (allFonts == null) {
3317 loadFonts();
3318 TreeMap<String, Font2D> fontMapNames = new TreeMap<>();
3319 /* warning: the number of composite fonts could change dynamically
3320 * if applications are allowed to create them. "allfonts" could
3321 * then be stale.
3322 */
3323 Font2D[] allfonts = getRegisteredFonts();
3324 for (int i=0; i < allfonts.length; i++) {
3325 if (!(allfonts[i] instanceof NativeFont)) {
3326 fontMapNames.put(allfonts[i].getFontName(null),
3327 allfonts[i]);
3328 }
3329 }
3330
3331 String[] platformNames = getFontNamesFromPlatform();
3332 if (platformNames != null) {
3333 for (int i=0; i<platformNames.length; i++) {
3334 if (!isNameForRegisteredFile(platformNames[i])) {
3335 fontMapNames.put(platformNames[i], null);
3336 }
3337 }
3338 }
3339
3340 String[] fontNames = null;
3341 if (fontMapNames.size() > 0) {
3342 fontNames = new String[fontMapNames.size()];
3343 Object [] keyNames = fontMapNames.keySet().toArray();
3344 for (int i=0; i < keyNames.length; i++) {
3345 fontNames[i] = (String)keyNames[i];
3346 }
3347 }
3348 Font[] fonts = new Font[fontNames.length];
3349 for (int i=0; i < fontNames.length; i++) {
3350 fonts[i] = new Font(fontNames[i], Font.PLAIN, 1);
3351 Font2D f2d = fontMapNames.get(fontNames[i]);
3352 if (f2d != null) {
3353 FontAccess.getFontAccess().setFont2D(fonts[i], f2d.handle);
3354 }
3355 }
3356 allFonts = fonts;
3357 }
3358
3359 Font []copyFonts = new Font[allFonts.length];
3360 System.arraycopy(allFonts, 0, copyFonts, 0, allFonts.length);
3361 return copyFonts;
3362 }
3363
3364 /**
3365 * Get a list of installed fonts in the requested {@link Locale}.
3366 * The list contains the fonts Family Names.
3367 * If Locale is null, the default locale is used.
3368 *
3369 * @param requestedLocale, if null the default locale is used.
3370 * @return list of installed fonts in the system.
3371 */
3372 public String[] getInstalledFontFamilyNames(Locale requestedLocale) {
3373 if (requestedLocale == null) {
3374 requestedLocale = Locale.getDefault();
3375 }
3376 if (allFamilies != null && lastDefaultLocale != null &&
3377 requestedLocale.equals(lastDefaultLocale)) {
3378 String[] copyFamilies = new String[allFamilies.length];
3379 System.arraycopy(allFamilies, 0, copyFamilies,
3380 0, allFamilies.length);
3381 return copyFamilies;
3382 }
3383
3384 TreeMap<String,String> familyNames = new TreeMap<String,String>();
3385 // these names are always there and aren't localised
3386 String str;
3387 str = Font.SERIF; familyNames.put(str.toLowerCase(), str);
3388 str = Font.SANS_SERIF; familyNames.put(str.toLowerCase(), str);
3389 str = Font.MONOSPACED; familyNames.put(str.toLowerCase(), str);
3390 str = Font.DIALOG; familyNames.put(str.toLowerCase(), str);
3391 str = Font.DIALOG_INPUT; familyNames.put(str.toLowerCase(), str);
3392
3393 /* Platform APIs may be used to get the set of available family
3394 * names for the current default locale so long as it is the same
3395 * as the start-up system locale, rather than loading all fonts.
3396 */
3397 if (requestedLocale.equals(getSystemStartupLocale()) &&
3398 getFamilyNamesFromPlatform(familyNames, requestedLocale)) {
3399 /* Augment platform names with JRE font family names */
3400 getJREFontFamilyNames(familyNames, requestedLocale);
3401 } else {
3402 loadFontFiles();
3403 Font2D[] physicalfonts = getPhysicalFonts();
3404 for (int i=0; i < physicalfonts.length; i++) {
3405 if (!(physicalfonts[i] instanceof NativeFont)) {
3406 String name =
3407 physicalfonts[i].getFamilyName(requestedLocale);
3408 familyNames.put(name.toLowerCase(requestedLocale), name);
3409 }
3410 }
3411 }
3412
3413 // Add any native font family names here
3414 addNativeFontFamilyNames(familyNames, requestedLocale);
3415
3416 String[] retval = new String[familyNames.size()];
3417 Object [] keyNames = familyNames.keySet().toArray();
3418 for (int i=0; i < keyNames.length; i++) {
3419 retval[i] = familyNames.get(keyNames[i]);
3420 }
3421 if (requestedLocale.equals(Locale.getDefault())) {
3422 lastDefaultLocale = requestedLocale;
3423 allFamilies = new String[retval.length];
3424 System.arraycopy(retval, 0, allFamilies, 0, allFamilies.length);
3425 }
3426 return retval;
3427 }
3428
3429 // Provides an aperture to add native font family names to the map
3430 protected void addNativeFontFamilyNames(TreeMap<String, String> familyNames, Locale requestedLocale) { }
3431
3432 public void register1dot0Fonts() {
3433 AccessController.doPrivileged(new PrivilegedAction<Void>() {
3434 public Void run() {
3435 String type1Dir = "/usr/openwin/lib/X11/fonts/Type1";
3436 registerFontsInDir(type1Dir, true, Font2D.TYPE1_RANK,
3437 false, false);
3438 return null;
3439 }
3440 });
3441 }
3442
3443 /* Really we need only the JRE fonts family names, but there's little
3444 * overhead in doing this the easy way by adding all the currently
3445 * known fonts.
3446 */
3447 protected void getJREFontFamilyNames(TreeMap<String,String> familyNames,
3448 Locale requestedLocale) {
3449 registerDeferredJREFonts(jreFontDirName);
3450 Font2D[] physicalfonts = getPhysicalFonts();
3451 for (int i=0; i < physicalfonts.length; i++) {
3452 if (!(physicalfonts[i] instanceof NativeFont)) {
3453 String name =
3454 physicalfonts[i].getFamilyName(requestedLocale);
3455 familyNames.put(name.toLowerCase(requestedLocale), name);
3456 }
3457 }
3458 }
3459
3460 /**
3461 * Default locale can be changed but we need to know the initial locale
3462 * as that is what is used by native code. Changing Java default locale
3463 * doesn't affect that.
3464 * Returns the locale in use when using native code to communicate
3465 * with platform APIs. On windows this is known as the "system" locale,
3466 * and it is usually the same as the platform locale, but not always,
3467 * so this method also checks an implementation property used only
3468 * on windows and uses that if set.
3469 */
3470 private static Locale systemLocale = null;
3471 private static Locale getSystemStartupLocale() {
3472 if (systemLocale == null) {
3473 systemLocale = AccessController.doPrivileged(new PrivilegedAction<Locale>() {
3474 public Locale run() {
3475 /* On windows the system locale may be different than the
3476 * user locale. This is an unsupported configuration, but
3477 * in that case we want to return a dummy locale that will
3478 * never cause a match in the usage of this API. This is
3479 * important because Windows documents that the family
3480 * names of fonts are enumerated using the language of
3481 * the system locale. BY returning a dummy locale in that
3482 * case we do not use the platform API which would not
3483 * return us the names we want.
3484 */
3485 String fileEncoding = System.getProperty("file.encoding", "");
3486 String sysEncoding = System.getProperty("sun.jnu.encoding");
3487 if (sysEncoding != null && !sysEncoding.equals(fileEncoding)) {
3488 return Locale.ROOT;
3489 }
3490
3491 String language = System.getProperty("user.language", "en");
3492 String country = System.getProperty("user.country","");
3493 String variant = System.getProperty("user.variant","");
3494 return new Locale(language, country, variant);
3495 }
3496 });
3497 }
3498 return systemLocale;
3499 }
3500
3501 void addToPool(FileFont font) {
3502
3503 FileFont fontFileToClose = null;
3504 int freeSlot = -1;
3505
3506 synchronized (fontFileCache) {
3507 /* Avoid duplicate entries in the pool, and don't close() it,
3508 * since this method is called only from within open().
3509 * Seeing a duplicate is most likely to happen if the thread
3510 * was interrupted during a read, forcing perhaps repeated
3511 * close and open calls and it eventually it ends up pointing
3512 * at the same slot.
3513 */
3514 for (int i=0;i<CHANNELPOOLSIZE;i++) {
3515 if (fontFileCache[i] == font) {
3516 return;
3517 }
3518 if (fontFileCache[i] == null && freeSlot < 0) {
3519 freeSlot = i;
3520 }
3521 }
3522 if (freeSlot >= 0) {
3523 fontFileCache[freeSlot] = font;
3524 return;
3525 } else {
3526 /* replace with new font. */
3527 fontFileToClose = fontFileCache[lastPoolIndex];
3528 fontFileCache[lastPoolIndex] = font;
3529 /* lastPoolIndex is updated so that the least recently opened
3530 * file will be closed next.
3531 */
3532 lastPoolIndex = (lastPoolIndex+1) % CHANNELPOOLSIZE;
3533 }
3534 }
3535 /* Need to close the font file outside of the synchronized block,
3536 * since its possible some other thread is in an open() call on
3537 * this font file, and could be holding its lock and the pool lock.
3538 * Releasing the pool lock allows that thread to continue, so it can
3539 * then release the lock on this font, allowing the close() call
3540 * below to proceed.
3541 * Also, calling close() is safe because any other thread using
3542 * the font we are closing() synchronizes all reading, so we
3543 * will not close the file while its in use.
3544 */
3545 if (fontFileToClose != null) {
3546 fontFileToClose.close();
3547 }
3548 }
3549
3550 protected FontUIResource getFontConfigFUIR(String family, int style,
3551 int size)
3552 {
3553 return new FontUIResource(family, style, size);
3554 }
3555 }