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 }
--- EOF ---