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