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