rev 60064 : 8248802: Add log helper methods to FontUtilities.java

   1 /*
   2  * Copyright (c) 1996, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.awt;
  27 
  28 import java.awt.Font;
  29 import java.io.DataInputStream;
  30 import java.io.DataOutputStream;
  31 import java.io.File;
  32 import java.io.FileInputStream;
  33 import java.io.InputStream;
  34 import java.io.IOException;
  35 import java.io.OutputStream;
  36 import java.nio.charset.Charset;
  37 import java.nio.charset.CharsetEncoder;
  38 import java.security.AccessController;
  39 import java.security.PrivilegedAction;
  40 import java.util.Arrays;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.Hashtable;
  44 import java.util.Locale;
  45 import java.util.Map.Entry;
  46 import java.util.Properties;
  47 import java.util.Set;
  48 import java.util.Vector;
  49 import sun.font.CompositeFontDescriptor;
  50 import sun.font.SunFontManager;
  51 import sun.font.FontManagerFactory;
  52 import sun.font.FontUtilities;
  53 import sun.util.logging.PlatformLogger;
  54 
  55 /**
  56  * Provides the definitions of the five logical fonts: Serif, SansSerif,
  57  * Monospaced, Dialog, and DialogInput. The necessary information
  58  * is obtained from fontconfig files.
  59  */
  60 public abstract class FontConfiguration {
  61 
  62     //static global runtime env
  63     protected static String osVersion;
  64     protected static String osName;
  65     protected static String encoding; // canonical name of default nio charset
  66     protected static Locale startupLocale = null;
  67     protected static Hashtable<String, String> localeMap = null;
  68     private static FontConfiguration fontConfig;
  69     private static PlatformLogger logger;
  70     protected static boolean isProperties = true;
  71 
  72     protected SunFontManager fontManager;
  73     protected boolean preferLocaleFonts;
  74     protected boolean preferPropFonts;
  75 
  76     private File fontConfigFile;
  77     private boolean foundOsSpecificFile;
  78     private boolean inited;
  79     private String javaLib;
  80 
  81     /* A default FontConfiguration must be created before an alternate
  82      * one to ensure proper static initialisation takes place.
  83      */
  84     public FontConfiguration(SunFontManager fm) {
  85         if (FontUtilities.debugFonts()) {
  86             FontUtilities.logInfo("Creating standard Font Configuration");

  87         }
  88         if (FontUtilities.debugFonts() && logger == null) {
  89             logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
  90         }
  91         fontManager = fm;
  92         setOsNameAndVersion();  /* static initialization */
  93         setEncoding();          /* static initialization */
  94         /* Separating out the file location from the rest of the
  95          * initialisation, so the caller has the option of doing
  96          * something else if a suitable file isn't found.
  97          */
  98         findFontConfigFile();
  99     }
 100 
 101     public synchronized boolean init() {
 102         if (!inited) {
 103             this.preferLocaleFonts = false;
 104             this.preferPropFonts = false;
 105             setFontConfiguration();
 106             readFontConfigFile(fontConfigFile);
 107             initFontConfig();
 108             inited = true;
 109         }
 110         return true;
 111     }
 112 
 113     public FontConfiguration(SunFontManager fm,
 114                              boolean preferLocaleFonts,
 115                              boolean preferPropFonts) {
 116         fontManager = fm;
 117         if (FontUtilities.debugFonts()) {
 118             FontUtilities.logInfo("Creating alternate Font Configuration");

 119         }
 120         this.preferLocaleFonts = preferLocaleFonts;
 121         this.preferPropFonts = preferPropFonts;
 122         /* fontConfig should be initialised by default constructor, and
 123          * its data tables can be shared, since readFontConfigFile doesn't
 124          * update any other state. Also avoid a doPrivileged block.
 125          */
 126         initFontConfig();
 127     }
 128 
 129     /**
 130      * Fills in this instance's osVersion and osName members. By
 131      * default uses the system properties os.name and os.version;
 132      * subclasses may override.
 133      */
 134     protected void setOsNameAndVersion() {
 135         osName = System.getProperty("os.name");
 136         osVersion = System.getProperty("os.version");
 137     }
 138 
 139     private void setEncoding() {
 140         encoding = Charset.defaultCharset().name();
 141         startupLocale = SunToolkit.getStartupLocale();
 142     }
 143 
 144     /////////////////////////////////////////////////////////////////////
 145     // methods for loading the FontConfig file                         //
 146     /////////////////////////////////////////////////////////////////////
 147 
 148     public boolean foundOsSpecificFile() {
 149         return foundOsSpecificFile;
 150     }
 151 
 152     /* Smoke test to see if we can trust this configuration by testing if
 153      * the first slot of a composite font maps to an installed file.
 154      */
 155     public boolean fontFilesArePresent() {
 156         init();
 157         short fontNameID = compFontNameIDs[0][0][0];
 158         short fileNameID = getComponentFileID(fontNameID);
 159         final String fileName = mapFileName(getComponentFileName(fileNameID));
 160         Boolean exists = java.security.AccessController.doPrivileged(
 161             new java.security.PrivilegedAction<Boolean>() {
 162                  public Boolean run() {
 163                      try {
 164                          File f = new File(fileName);
 165                          return Boolean.valueOf(f.exists());
 166                      }
 167                      catch (Exception e) {
 168                          return Boolean.FALSE;
 169                      }
 170                  }
 171                 });
 172         return exists.booleanValue();
 173     }
 174 
 175     private void findFontConfigFile() {
 176 
 177         foundOsSpecificFile = true; // default assumption.
 178         String javaHome = System.getProperty("java.home");
 179         if (javaHome == null) {
 180             throw new Error("java.home property not set");
 181         }
 182         javaLib = javaHome + File.separator + "lib";
 183         String javaConfFonts = javaHome +
 184                                File.separator + "conf" +
 185                                File.separator + "fonts";
 186         String userConfigFile = System.getProperty("sun.awt.fontconfig");
 187         if (userConfigFile != null) {
 188             fontConfigFile = new File(userConfigFile);
 189         } else {
 190             fontConfigFile = findFontConfigFile(javaConfFonts);
 191             if (fontConfigFile == null) {
 192                 fontConfigFile = findFontConfigFile(javaLib);
 193             }
 194         }
 195     }
 196 
 197     private void readFontConfigFile(File f) {
 198         /* This is invoked here as readFontConfigFile is only invoked
 199          * once per VM, and always in a privileged context, thus the
 200          * directory containing installed fall back fonts is accessed
 201          * from this context
 202          */
 203         getInstalledFallbackFonts(javaLib);
 204 
 205         if (f != null) {
 206             try {
 207                 FileInputStream in = new FileInputStream(f.getPath());
 208                 if (isProperties) {
 209                     loadProperties(in);
 210                 } else {
 211                     loadBinary(in);
 212                 }
 213                 in.close();
 214                 if (FontUtilities.debugFonts()) {
 215                     logger.config("Read logical font configuration from " + f);
 216                 }
 217             } catch (IOException e) {
 218                 if (FontUtilities.debugFonts()) {
 219                     logger.config("Failed to read logical font configuration from " + f);
 220                 }
 221             }
 222         }
 223         String version = getVersion();
 224         if (!"1".equals(version) && FontUtilities.debugFonts()) {
 225             logger.config("Unsupported fontconfig version: " + version);
 226         }
 227     }
 228 
 229     protected void getInstalledFallbackFonts(String javaLib) {
 230         String fallbackDirName = javaLib + File.separator +
 231             "fonts" + File.separator + "fallback";
 232 
 233         File fallbackDir = new File(fallbackDirName);
 234         if (fallbackDir.exists() && fallbackDir.isDirectory()) {
 235             String[] ttfs = fallbackDir.list(fontManager.getTrueTypeFilter());
 236             String[] t1s = fallbackDir.list(fontManager.getType1Filter());
 237             int numTTFs = (ttfs == null) ? 0 : ttfs.length;
 238             int numT1s = (t1s == null) ? 0 : t1s.length;
 239             int len = numTTFs + numT1s;
 240             if (numTTFs + numT1s == 0) {
 241                 return;
 242             }
 243             installedFallbackFontFiles = new String[len];
 244             for (int i=0; i<numTTFs; i++) {
 245                 installedFallbackFontFiles[i] =
 246                     fallbackDir + File.separator + ttfs[i];
 247             }
 248             for (int i=0; i<numT1s; i++) {
 249                 installedFallbackFontFiles[i+numTTFs] =
 250                     fallbackDir + File.separator + t1s[i];
 251             }
 252             fontManager.registerFontsInDir(fallbackDirName);
 253         }
 254     }
 255 
 256     private File findImpl(String fname) {
 257         File f = new File(fname + ".properties");
 258         if (FontUtilities.debugFonts()) {
 259             logger.info("Looking for text fontconfig file : " + f);
 260         }
 261         if (f.canRead()) {
 262             if (FontUtilities.debugFonts()) {
 263                 logger.info("Found file : " + f);
 264             }
 265             isProperties = true;
 266             return f;
 267         }
 268         f = new File(fname + ".bfc");
 269         if (FontUtilities.debugFonts()) {
 270             logger.info("Looking for binary fontconfig file : " + f);
 271         }
 272         if (f.canRead()) {
 273             if (FontUtilities.debugFonts()) {
 274                 logger.info("Found file : " + f);
 275             }
 276             isProperties = false;
 277             return f;
 278         }
 279         return null;
 280     }
 281 
 282     private File findFontConfigFile(String dir) {
 283         if (!(new File(dir)).exists()) {
 284             return null;
 285         }
 286         String baseName = dir + File.separator + "fontconfig";
 287         File configFile;
 288         String osMajorVersion = null;
 289         if (osVersion != null && osName != null) {
 290             configFile = findImpl(baseName + "." + osName + "." + osVersion);
 291             if (configFile != null) {
 292                 return configFile;
 293             }
 294             int decimalPointIndex = osVersion.indexOf('.');
 295             if (decimalPointIndex != -1) {
 296                 osMajorVersion = osVersion.substring(0, osVersion.indexOf('.'));
 297                 configFile = findImpl(baseName + "." + osName + "." + osMajorVersion);
 298                 if (configFile != null) {
 299                     return configFile;
 300                 }
 301             }
 302         }
 303         if (osName != null) {
 304             configFile = findImpl(baseName + "." + osName);
 305             if (configFile != null) {
 306                 return configFile;
 307             }
 308         }
 309         if (osVersion != null) {
 310             configFile = findImpl(baseName + "." + osVersion);
 311             if (configFile != null) {
 312                 return configFile;
 313             }
 314             if (osMajorVersion != null) {
 315                 configFile = findImpl(baseName + "." + osMajorVersion);
 316                 if (configFile != null) {
 317                     return configFile;
 318                 }
 319             }
 320         }
 321         foundOsSpecificFile = false;
 322 
 323         configFile = findImpl(baseName);
 324         if (configFile != null) {
 325             return configFile;
 326         }
 327         if (FontUtilities.debugFonts()) {
 328             logger.info("Did not find a fontconfig file.");
 329         }
 330         return null;
 331     }
 332 
 333     /* Initialize the internal data tables from binary format font
 334      * configuration file.
 335      */
 336     public static void loadBinary(InputStream inStream) throws IOException {
 337         DataInputStream in = new DataInputStream(inStream);
 338         head = readShortTable(in, HEAD_LENGTH);
 339         int[] tableSizes = new int[INDEX_TABLEEND];
 340         for (int i = 0; i < INDEX_TABLEEND; i++) {
 341             tableSizes[i] = head[i + 1] - head[i];
 342         }
 343         table_scriptIDs       = readShortTable(in, tableSizes[INDEX_scriptIDs]);
 344         table_scriptFonts     = readShortTable(in, tableSizes[INDEX_scriptFonts]);
 345         table_elcIDs          = readShortTable(in, tableSizes[INDEX_elcIDs]);
 346         table_sequences        = readShortTable(in, tableSizes[INDEX_sequences]);
 347         table_fontfileNameIDs = readShortTable(in, tableSizes[INDEX_fontfileNameIDs]);
 348         table_componentFontNameIDs = readShortTable(in, tableSizes[INDEX_componentFontNameIDs]);
 349         table_filenames       = readShortTable(in, tableSizes[INDEX_filenames]);
 350         table_awtfontpaths    = readShortTable(in, tableSizes[INDEX_awtfontpaths]);
 351         table_exclusions      = readShortTable(in, tableSizes[INDEX_exclusions]);
 352         table_proportionals   = readShortTable(in, tableSizes[INDEX_proportionals]);
 353         table_scriptFontsMotif   = readShortTable(in, tableSizes[INDEX_scriptFontsMotif]);
 354         table_alphabeticSuffix   = readShortTable(in, tableSizes[INDEX_alphabeticSuffix]);
 355         table_stringIDs       = readShortTable(in, tableSizes[INDEX_stringIDs]);
 356 
 357         //StringTable cache
 358         stringCache = new String[table_stringIDs.length + 1];
 359 
 360         int len = tableSizes[INDEX_stringTable];
 361         byte[] bb = new byte[len * 2];
 362         table_stringTable = new char[len];
 363         in.read(bb);
 364         int i = 0, j = 0;
 365         while (i < len) {
 366            table_stringTable[i++] = (char)(bb[j++] << 8 | (bb[j++] & 0xff));
 367         }
 368         if (verbose) {
 369             dump();
 370         }
 371     }
 372 
 373     /* Generate a binary format font configuration from internal data
 374      * tables.
 375      */
 376     public static void saveBinary(OutputStream out) throws IOException {
 377         sanityCheck();
 378 
 379         DataOutputStream dataOut = new DataOutputStream(out);
 380         writeShortTable(dataOut, head);
 381         writeShortTable(dataOut, table_scriptIDs);
 382         writeShortTable(dataOut, table_scriptFonts);
 383         writeShortTable(dataOut, table_elcIDs);
 384         writeShortTable(dataOut, table_sequences);
 385         writeShortTable(dataOut, table_fontfileNameIDs);
 386         writeShortTable(dataOut, table_componentFontNameIDs);
 387         writeShortTable(dataOut, table_filenames);
 388         writeShortTable(dataOut, table_awtfontpaths);
 389         writeShortTable(dataOut, table_exclusions);
 390         writeShortTable(dataOut, table_proportionals);
 391         writeShortTable(dataOut, table_scriptFontsMotif);
 392         writeShortTable(dataOut, table_alphabeticSuffix);
 393         writeShortTable(dataOut, table_stringIDs);
 394         //stringTable
 395         dataOut.writeChars(new String(table_stringTable));
 396         out.close();
 397         if (verbose) {
 398             dump();
 399         }
 400     }
 401 
 402     //private static boolean loadingProperties;
 403     private static short stringIDNum;
 404     private static short[] stringIDs;
 405     private static StringBuilder stringTable;
 406 
 407     public static void loadProperties(InputStream in) throws IOException {
 408         //loadingProperties = true;
 409         //StringID starts from "1", "0" is reserved for "not defined"
 410         stringIDNum = 1;
 411         stringIDs = new short[1000];
 412         stringTable = new StringBuilder(4096);
 413 
 414         if (verbose && logger == null) {
 415             logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
 416         }
 417         new PropertiesHandler().load(in);
 418 
 419         //loadingProperties = false;
 420         stringIDs = null;
 421         stringTable = null;
 422     }
 423 
 424 
 425     /////////////////////////////////////////////////////////////////////
 426     // methods for initializing the FontConfig                         //
 427     /////////////////////////////////////////////////////////////////////
 428 
 429     /**
 430      *  set initLocale, initEncoding and initELC for this FontConfig object
 431      *  currently we just simply use the startup locale and encoding
 432      */
 433     private void initFontConfig() {
 434         initLocale = startupLocale;
 435         initEncoding = encoding;
 436         if (preferLocaleFonts && !willReorderForStartupLocale()) {
 437             preferLocaleFonts = false;
 438         }
 439         initELC = getInitELC();
 440         initAllComponentFonts();
 441     }
 442 
 443     //"ELC" stands for "Encoding.Language.Country". This method returns
 444     //the ID of the matched elc setting of "initLocale" in elcIDs table.
 445     //If no match is found, it returns the default ID, which is
 446     //"NULL.NULL.NULL" in elcIDs table.
 447     private short getInitELC() {
 448         if (initELC != -1) {
 449             return initELC;
 450         }
 451         HashMap <String, Integer> elcIDs = new HashMap<String, Integer>();
 452         for (int i = 0; i < table_elcIDs.length; i++) {
 453             elcIDs.put(getString(table_elcIDs[i]), i);
 454         }
 455         String language = initLocale.getLanguage();
 456         String country = initLocale.getCountry();
 457         String elc;
 458         if (elcIDs.containsKey(elc=initEncoding + "." + language + "." + country)
 459             || elcIDs.containsKey(elc=initEncoding + "." + language)
 460             || elcIDs.containsKey(elc=initEncoding)) {
 461             initELC = elcIDs.get(elc).shortValue();
 462         } else {
 463             initELC = elcIDs.get("NULL.NULL.NULL").shortValue();
 464         }
 465         int i = 0;
 466         while (i < table_alphabeticSuffix.length) {
 467             if (initELC == table_alphabeticSuffix[i]) {
 468                 alphabeticSuffix = getString(table_alphabeticSuffix[i + 1]);
 469                 return initELC;
 470             }
 471             i += 2;
 472         }
 473         return initELC;
 474     }
 475 
 476     public static boolean verbose;
 477     private short    initELC = -1;
 478     private Locale   initLocale;
 479     private String   initEncoding;
 480     private String   alphabeticSuffix;
 481 
 482     private short[][][] compFontNameIDs = new short[NUM_FONTS][NUM_STYLES][];
 483     private int[][][] compExclusions = new int[NUM_FONTS][][];
 484     private int[] compCoreNum = new int[NUM_FONTS];
 485 
 486     private Set<Short> coreFontNameIDs = new HashSet<Short>();
 487     private Set<Short> fallbackFontNameIDs = new HashSet<Short>();
 488 
 489     private void initAllComponentFonts() {
 490         short[] fallbackScripts = getFallbackScripts();
 491         for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) {
 492             short[] coreScripts = getCoreScripts(fontIndex);
 493             compCoreNum[fontIndex] = coreScripts.length;
 494             /*
 495             System.out.println("coreScriptID=" + table_sequences[initELC * 5 + fontIndex]);
 496             for (int i = 0; i < coreScripts.length; i++) {
 497             System.out.println("  " + i + " :" + getString(table_scriptIDs[coreScripts[i]]));
 498             }
 499             */
 500             //init exclusionRanges
 501             int[][] exclusions = new int[coreScripts.length][];
 502             for (int i = 0; i < coreScripts.length; i++) {
 503                 exclusions[i] = getExclusionRanges(coreScripts[i]);
 504             }
 505             compExclusions[fontIndex] = exclusions;
 506             //init componentFontNames
 507             for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) {
 508                 int index;
 509                 short[] nameIDs = new short[coreScripts.length + fallbackScripts.length];
 510                 //core
 511                 for (index = 0; index < coreScripts.length; index++) {
 512                     nameIDs[index] = getComponentFontID(coreScripts[index],
 513                                                fontIndex, styleIndex);
 514                     if (preferLocaleFonts && localeMap != null &&
 515                             fontManager.usingAlternateFontforJALocales()) {
 516                         nameIDs[index] = remapLocaleMap(fontIndex, styleIndex,
 517                                                         coreScripts[index], nameIDs[index]);
 518                     }
 519                     if (preferPropFonts) {
 520                         nameIDs[index] = remapProportional(fontIndex, nameIDs[index]);
 521                     }
 522                     //System.out.println("nameid=" + nameIDs[index]);
 523                     coreFontNameIDs.add(nameIDs[index]);
 524                 }
 525                 //fallback
 526                 for (int i = 0; i < fallbackScripts.length; i++) {
 527                     short id = getComponentFontID(fallbackScripts[i],
 528                                                fontIndex, styleIndex);
 529                     if (preferLocaleFonts && localeMap != null &&
 530                             fontManager.usingAlternateFontforJALocales()) {
 531                         id = remapLocaleMap(fontIndex, styleIndex, fallbackScripts[i], id);
 532                     }
 533                     if (preferPropFonts) {
 534                         id = remapProportional(fontIndex, id);
 535                     }
 536                     if (contains(nameIDs, id, index)) {
 537                         continue;
 538                     }
 539                     /*
 540                       System.out.println("fontIndex=" + fontIndex + ", styleIndex=" + styleIndex
 541                            + ", fbIndex=" + i + ",fbS=" + fallbackScripts[i] + ", id=" + id);
 542                     */
 543                     fallbackFontNameIDs.add(id);
 544                     nameIDs[index++] = id;
 545                 }
 546                 if (index < nameIDs.length) {
 547                     short[] newNameIDs = new short[index];
 548                     System.arraycopy(nameIDs, 0, newNameIDs, 0, index);
 549                     nameIDs = newNameIDs;
 550                 }
 551                 compFontNameIDs[fontIndex][styleIndex] = nameIDs;
 552             }
 553         }
 554    }
 555 
 556    private short remapLocaleMap(int fontIndex, int styleIndex, short scriptID, short fontID) {
 557         String scriptName = getString(table_scriptIDs[scriptID]);
 558 
 559         String value = localeMap.get(scriptName);
 560         if (value == null) {
 561             String fontName = fontNames[fontIndex];
 562             String styleName = styleNames[styleIndex];
 563             value = localeMap.get(fontName + "." + styleName + "." + scriptName);
 564         }
 565         if (value == null) {
 566             return fontID;
 567         }
 568 
 569         for (int i = 0; i < table_componentFontNameIDs.length; i++) {
 570             String name = getString(table_componentFontNameIDs[i]);
 571             if (value.equalsIgnoreCase(name)) {
 572                 fontID = (short)i;
 573                 break;
 574             }
 575         }
 576         return fontID;
 577     }
 578 
 579     public static boolean hasMonoToPropMap() {
 580         return table_proportionals != null && table_proportionals.length != 0;
 581     }
 582 
 583     private short remapProportional(int fontIndex, short id) {
 584     if (preferPropFonts &&
 585         table_proportionals.length != 0 &&
 586         fontIndex != 2 &&         //"monospaced"
 587         fontIndex != 4) {         //"dialoginput"
 588             int i = 0;
 589             while (i < table_proportionals.length) {
 590                 if (table_proportionals[i] == id) {
 591                     return table_proportionals[i + 1];
 592                 }
 593                 i += 2;
 594             }
 595         }
 596         return id;
 597     }
 598 
 599     /////////////////////////////////////////////////////////////////////
 600     // Methods for handling font and style names                       //
 601     /////////////////////////////////////////////////////////////////////
 602     protected static final int NUM_FONTS = 5;
 603     protected static final int NUM_STYLES = 4;
 604     protected static final String[] fontNames
 605             = {"serif", "sansserif", "monospaced", "dialog", "dialoginput"};
 606     protected static final String[] publicFontNames
 607             = {Font.SERIF, Font.SANS_SERIF, Font.MONOSPACED, Font.DIALOG,
 608                Font.DIALOG_INPUT};
 609     protected static final String[] styleNames
 610             = {"plain", "bold", "italic", "bolditalic"};
 611 
 612     /**
 613      * Checks whether the given font family name is a valid logical font name.
 614      * The check is case insensitive.
 615      */
 616     public static boolean isLogicalFontFamilyName(String fontName) {
 617         return isLogicalFontFamilyNameLC(fontName.toLowerCase(Locale.ENGLISH));
 618     }
 619 
 620     /**
 621      * Checks whether the given font family name is a valid logical font name.
 622      * The check is case sensitive.
 623      */
 624     public static boolean isLogicalFontFamilyNameLC(String fontName) {
 625         for (int i = 0; i < fontNames.length; i++) {
 626             if (fontName.equals(fontNames[i])) {
 627                 return true;
 628             }
 629         }
 630         return false;
 631     }
 632 
 633     /**
 634      * Checks whether the given style name is a valid logical font style name.
 635      */
 636     private static boolean isLogicalFontStyleName(String styleName) {
 637         for (int i = 0; i < styleNames.length; i++) {
 638             if (styleName.equals(styleNames[i])) {
 639                 return true;
 640             }
 641         }
 642         return false;
 643     }
 644 
 645     /**
 646      * Checks whether the given font face name is a valid logical font name.
 647      * The check is case insensitive.
 648      */
 649     public static boolean isLogicalFontFaceName(String fontName) {
 650         return isLogicalFontFaceNameLC(fontName.toLowerCase(Locale.ENGLISH));
 651     }
 652 
 653    /**
 654     * Checks whether the given font face name is a valid logical font name.
 655     * The check is case sensitive.
 656     */
 657     public static boolean isLogicalFontFaceNameLC(String fontName) {
 658         int period = fontName.indexOf('.');
 659         if (period >= 0) {
 660             String familyName = fontName.substring(0, period);
 661             String styleName = fontName.substring(period + 1);
 662             return isLogicalFontFamilyName(familyName) &&
 663                     isLogicalFontStyleName(styleName);
 664         } else {
 665             return isLogicalFontFamilyName(fontName);
 666         }
 667     }
 668 
 669     protected static int getFontIndex(String fontName) {
 670         return getArrayIndex(fontNames, fontName);
 671     }
 672 
 673     protected static int getStyleIndex(String styleName) {
 674         return getArrayIndex(styleNames, styleName);
 675     }
 676 
 677     private static int getArrayIndex(String[] names, String name) {
 678         for (int i = 0; i < names.length; i++) {
 679             if (name.equals(names[i])) {
 680                 return i;
 681             }
 682         }
 683         assert false;
 684         return 0;
 685     }
 686 
 687     protected static int getStyleIndex(int style) {
 688         switch (style) {
 689             case Font.PLAIN:
 690                 return 0;
 691             case Font.BOLD:
 692                 return 1;
 693             case Font.ITALIC:
 694                 return 2;
 695             case Font.BOLD | Font.ITALIC:
 696                 return 3;
 697             default:
 698                 return 0;
 699         }
 700     }
 701 
 702     protected static String getFontName(int fontIndex) {
 703         return fontNames[fontIndex];
 704     }
 705 
 706     protected static String getStyleName(int styleIndex) {
 707         return styleNames[styleIndex];
 708     }
 709 
 710     /**
 711      * Returns the font face name for the given logical font
 712      * family name and style.
 713      * The style argument is interpreted as in java.awt.Font.Font.
 714      */
 715     public static String getLogicalFontFaceName(String familyName, int style) {
 716         assert isLogicalFontFamilyName(familyName);
 717         return familyName.toLowerCase(Locale.ENGLISH) + "." + getStyleString(style);
 718     }
 719 
 720     /**
 721      * Returns the string typically used in properties files
 722      * for the given style.
 723      * The style argument is interpreted as in java.awt.Font.Font.
 724      */
 725     public static String getStyleString(int style) {
 726         return getStyleName(getStyleIndex(style));
 727     }
 728 
 729     /**
 730      * Returns a fallback name for the given font name. For a few known
 731      * font names, matching logical font names are returned. For all
 732      * other font names, defaultFallback is returned.
 733      * defaultFallback differs between AWT and 2D.
 734      */
 735     public abstract String getFallbackFamilyName(String fontName, String defaultFallback);
 736 
 737     /**
 738      * Returns the 1.1 equivalent for some old 1.0 font family names for
 739      * which we need to maintain compatibility in some configurations.
 740      * Returns null for other font names.
 741      */
 742     protected String getCompatibilityFamilyName(String fontName) {
 743         fontName = fontName.toLowerCase(Locale.ENGLISH);
 744         if (fontName.equals("timesroman")) {
 745             return "serif";
 746         } else if (fontName.equals("helvetica")) {
 747             return "sansserif";
 748         } else if (fontName.equals("courier")) {
 749             return "monospaced";
 750         }
 751         return null;
 752     }
 753 
 754     protected static String[] installedFallbackFontFiles = null;
 755 
 756     /**
 757      * Maps a file name given in the font configuration file
 758      * to a format appropriate for the platform.
 759      */
 760     protected String mapFileName(String fileName) {
 761         return fileName;
 762     }
 763 
 764     //////////////////////////////////////////////////////////////////////
 765     //  reordering                                                      //
 766     //////////////////////////////////////////////////////////////////////
 767 
 768     /* Mappings from file encoding to font config name for font supporting
 769      * the corresponding language. This is filled in by initReorderMap()
 770      */
 771     protected HashMap<String, Object> reorderMap = null;
 772 
 773     /* Platform-specific mappings */
 774     protected abstract void initReorderMap();
 775 
 776     /* Move item at index "src" to "dst", shuffling all values in
 777      * between down
 778      */
 779     private void shuffle(String[] seq, int src, int dst) {
 780         if (dst >= src) {
 781             return;
 782         }
 783         String tmp = seq[src];
 784         for (int i=src; i>dst; i--) {
 785             seq[i] = seq[i-1];
 786         }
 787         seq[dst] = tmp;
 788     }
 789 
 790     /* Called to determine if there's a re-order sequence for this locale/
 791      * encoding. If there's none then the caller can "bail" and avoid
 792      * unnecessary work
 793      */
 794     public static boolean willReorderForStartupLocale() {
 795         return getReorderSequence() != null;
 796     }
 797 
 798     private static Object getReorderSequence() {
 799         if (fontConfig.reorderMap == null) {
 800              fontConfig.initReorderMap();
 801         }
 802         HashMap<String, Object> reorderMap = fontConfig.reorderMap;
 803 
 804         /* Find the most specific mapping */
 805         String language = startupLocale.getLanguage();
 806         String country = startupLocale.getCountry();
 807         Object val = reorderMap.get(encoding + "." + language + "." + country);
 808         if (val == null) {
 809             val = reorderMap.get(encoding + "." + language);
 810         }
 811         if (val == null) {
 812             val = reorderMap.get(encoding);
 813         }
 814         return val;
 815     }
 816 
 817     /* This method reorders the sequence such that the matches for the
 818      * file encoding are moved ahead of other elements.
 819      * If an encoding uses more than one font, they are all moved up.
 820      */
 821      private void reorderSequenceForLocale(String[] seq) {
 822         Object val =  getReorderSequence();
 823         if (val instanceof String) {
 824             for (int i=0; i< seq.length; i++) {
 825                 if (seq[i].equals(val)) {
 826                     shuffle(seq, i, 0);
 827                     return;
 828                 }
 829             }
 830         } else if (val instanceof String[]) {
 831             String[] fontLangs = (String[])val;
 832             for (int l=0; l<fontLangs.length;l++) {
 833                 for (int i=0; i<seq.length;i++) {
 834                     if (seq[i].equals(fontLangs[l])) {
 835                         shuffle(seq, i, l);
 836                     }
 837                 }
 838             }
 839         }
 840     }
 841 
 842     private static Vector<String> splitSequence(String sequence) {
 843         //String.split would be more convenient, but incurs big performance penalty
 844         Vector<String> parts = new Vector<>();
 845         int start = 0;
 846         int end;
 847         while ((end = sequence.indexOf(',', start)) >= 0) {
 848             parts.add(sequence.substring(start, end));
 849             start = end + 1;
 850         }
 851         if (sequence.length() > start) {
 852             parts.add(sequence.substring(start, sequence.length()));
 853         }
 854         return parts;
 855     }
 856 
 857     protected String[] split(String sequence) {
 858         Vector<String> v = splitSequence(sequence);
 859         return v.toArray(new String[0]);
 860     }
 861 
 862     ////////////////////////////////////////////////////////////////////////
 863     // Methods for extracting information from the fontconfig data for AWT//
 864     ////////////////////////////////////////////////////////////////////////
 865     private Hashtable<String, Charset> charsetRegistry = new Hashtable<>(5);
 866 
 867     /**
 868      * Returns FontDescriptors describing the physical fonts used for the
 869      * given logical font name and style. The font name is interpreted
 870      * in a case insensitive way.
 871      * The style argument is interpreted as in java.awt.Font.Font.
 872      */
 873     public FontDescriptor[] getFontDescriptors(String fontName, int style) {
 874         assert isLogicalFontFamilyName(fontName);
 875         fontName = fontName.toLowerCase(Locale.ENGLISH);
 876         int fontIndex = getFontIndex(fontName);
 877         int styleIndex = getStyleIndex(style);
 878         return getFontDescriptors(fontIndex, styleIndex);
 879     }
 880     private FontDescriptor[][][] fontDescriptors =
 881         new FontDescriptor[NUM_FONTS][NUM_STYLES][];
 882 
 883     private FontDescriptor[] getFontDescriptors(int fontIndex, int styleIndex) {
 884         FontDescriptor[] descriptors = fontDescriptors[fontIndex][styleIndex];
 885         if (descriptors == null) {
 886             descriptors = buildFontDescriptors(fontIndex, styleIndex);
 887             fontDescriptors[fontIndex][styleIndex] = descriptors;
 888         }
 889         return descriptors;
 890     }
 891 
 892     protected FontDescriptor[] buildFontDescriptors(int fontIndex, int styleIndex) {
 893         String fontName = fontNames[fontIndex];
 894         String styleName = styleNames[styleIndex];
 895 
 896         short[] scriptIDs = getCoreScripts(fontIndex);
 897         short[] nameIDs = compFontNameIDs[fontIndex][styleIndex];
 898         String[] sequence = new String[scriptIDs.length];
 899         String[] names = new String[scriptIDs.length];
 900         for (int i = 0; i < sequence.length; i++) {
 901             names[i] = getComponentFontName(nameIDs[i]);
 902             sequence[i] = getScriptName(scriptIDs[i]);
 903             if (alphabeticSuffix != null && "alphabetic".equals(sequence[i])) {
 904                 sequence[i] = sequence[i] + "/" + alphabeticSuffix;
 905             }
 906         }
 907         int[][] fontExclusionRanges = compExclusions[fontIndex];
 908 
 909         FontDescriptor[] descriptors = new FontDescriptor[names.length];
 910 
 911         for (int i = 0; i < names.length; i++) {
 912             String awtFontName;
 913             String encoding;
 914 
 915             awtFontName = makeAWTFontName(names[i], sequence[i]);
 916 
 917             // look up character encoding
 918             encoding = getEncoding(names[i], sequence[i]);
 919             if (encoding == null) {
 920                 encoding = "default";
 921             }
 922             CharsetEncoder enc
 923                     = getFontCharsetEncoder(encoding.trim(), awtFontName);
 924 
 925             // we already have the exclusion ranges
 926             int[] exclusionRanges = fontExclusionRanges[i];
 927 
 928             // create descriptor
 929             descriptors[i] = new FontDescriptor(awtFontName, enc, exclusionRanges);
 930         }
 931         return descriptors;
 932     }
 933 
 934     /**
 935      * Returns the AWT font name for the given platform font name and
 936      * character subset.
 937      */
 938     protected String makeAWTFontName(String platformFontName,
 939             String characterSubsetName) {
 940         return platformFontName;
 941     }
 942 
 943     /**
 944      * Returns the java.io name of the platform character encoding for the
 945      * given AWT font name and character subset. May return "default"
 946      * to indicate that getDefaultFontCharset should be called to obtain
 947      * a charset encoder.
 948      */
 949     protected abstract String getEncoding(String awtFontName,
 950             String characterSubsetName);
 951 
 952     private CharsetEncoder getFontCharsetEncoder(final String charsetName,
 953             String fontName) {
 954 
 955         Charset fc = null;
 956         if (charsetName.equals("default")) {
 957             fc = charsetRegistry.get(fontName);
 958         } else {
 959             fc = charsetRegistry.get(charsetName);
 960         }
 961         if (fc != null) {
 962             return fc.newEncoder();
 963         }
 964 
 965         if (!charsetName.startsWith("sun.awt.") && !charsetName.equals("default")) {
 966             fc = Charset.forName(charsetName);
 967         } else {
 968             Class<?> fcc = AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
 969                     public Class<?> run() {
 970                         try {
 971                             return Class.forName(charsetName, true,
 972                                                  ClassLoader.getSystemClassLoader());
 973                         } catch (ClassNotFoundException e) {
 974                         }
 975                         return null;
 976                     }
 977                 });
 978 
 979             if (fcc != null) {
 980                 try {
 981                     fc = (Charset) fcc.getDeclaredConstructor().newInstance();
 982                 } catch (Exception e) {
 983                 }
 984             }
 985         }
 986         if (fc == null) {
 987             fc = getDefaultFontCharset(fontName);
 988         }
 989 
 990         if (charsetName.equals("default")){
 991             charsetRegistry.put(fontName, fc);
 992         } else {
 993             charsetRegistry.put(charsetName, fc);
 994         }
 995         return fc.newEncoder();
 996     }
 997 
 998     protected abstract Charset getDefaultFontCharset(
 999             String fontName);
1000 
1001     /* This retrieves the platform font directories (path) calculated
1002      * by setAWTFontPathSequence(String[]). The default implementation
1003      * returns null, its expected that X11 platforms may return
1004      * non-null.
1005      */
1006     public HashSet<String> getAWTFontPathSet() {
1007         return null;
1008     }
1009 
1010     ////////////////////////////////////////////////////////////////////////
1011     // methods for extracting information from the fontconfig data for 2D //
1012     ////////////////////////////////////////////////////////////////////////
1013 
1014     /**
1015      * Returns an array of composite font descriptors for all logical font
1016      * faces.
1017      */
1018     public CompositeFontDescriptor[] get2DCompositeFontInfo() {
1019         CompositeFontDescriptor[] result =
1020                 new CompositeFontDescriptor[NUM_FONTS * NUM_STYLES];
1021         String defaultFontFile = fontManager.getDefaultFontFile();
1022         String defaultFontFaceName = fontManager.getDefaultFontFaceName();
1023 
1024         for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) {
1025             String fontName = publicFontNames[fontIndex];
1026 
1027             // determine exclusion ranges for font
1028             // AWT uses separate exclusion range array per component font.
1029             // 2D packs all range boundaries into one array.
1030             // Both use separate entries for lower and upper boundary.
1031             int[][] exclusions = compExclusions[fontIndex];
1032             int numExclusionRanges = 0;
1033             for (int i = 0; i < exclusions.length; i++) {
1034                 numExclusionRanges += exclusions[i].length;
1035             }
1036             int[] exclusionRanges = new int[numExclusionRanges];
1037             int[] exclusionRangeLimits = new int[exclusions.length];
1038             int exclusionRangeIndex = 0;
1039             int exclusionRangeLimitIndex = 0;
1040             for (int i = 0; i < exclusions.length; i++) {
1041                 int[] componentRanges = exclusions[i];
1042                 for (int j = 0; j < componentRanges.length; ) {
1043                     int value = componentRanges[j];
1044                     exclusionRanges[exclusionRangeIndex++] = componentRanges[j++];
1045                     exclusionRanges[exclusionRangeIndex++] = componentRanges[j++];
1046                 }
1047                 exclusionRangeLimits[i] = exclusionRangeIndex;
1048             }
1049             // other info is per style
1050             for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) {
1051                 int maxComponentFontCount = compFontNameIDs[fontIndex][styleIndex].length;
1052                 // fall back fonts listed in the lib/fonts/fallback directory
1053                 if (installedFallbackFontFiles != null) {
1054                     maxComponentFontCount += installedFallbackFontFiles.length;
1055                 }
1056                 String faceName = fontName + "." + styleNames[styleIndex];
1057 
1058                 // determine face names and file names of component fonts
1059                 String[] componentFaceNames = new String[maxComponentFontCount];
1060                 String[] componentFileNames = new String[maxComponentFontCount];
1061 
1062                 int index;
1063                 for (index = 0; index < compFontNameIDs[fontIndex][styleIndex].length; index++) {
1064                     short fontNameID = compFontNameIDs[fontIndex][styleIndex][index];
1065                     short fileNameID = getComponentFileID(fontNameID);
1066                     componentFaceNames[index] = getFaceNameFromComponentFontName(getComponentFontName(fontNameID));
1067                     componentFileNames[index] = mapFileName(getComponentFileName(fileNameID));
1068                     if (componentFileNames[index] == null ||
1069                         needToSearchForFile(componentFileNames[index])) {
1070                         componentFileNames[index] = getFileNameFromComponentFontName(getComponentFontName(fontNameID));
1071                     }
1072                     /*
1073                     System.out.println(publicFontNames[fontIndex] + "." + styleNames[styleIndex] + "."
1074                         + getString(table_scriptIDs[coreScripts[index]]) + "=" + componentFileNames[index]);
1075                     */
1076                 }
1077 
1078                 if (installedFallbackFontFiles != null) {
1079                     for (int ifb=0; ifb<installedFallbackFontFiles.length; ifb++) {
1080                         componentFaceNames[index] = null;
1081                         componentFileNames[index] = installedFallbackFontFiles[ifb];
1082                         index++;
1083                     }
1084                 }
1085 
1086                 if (index < maxComponentFontCount) {
1087                     String[] newComponentFaceNames = new String[index];
1088                     System.arraycopy(componentFaceNames, 0, newComponentFaceNames, 0, index);
1089                     componentFaceNames = newComponentFaceNames;
1090                     String[] newComponentFileNames = new String[index];
1091                     System.arraycopy(componentFileNames, 0, newComponentFileNames, 0, index);
1092                     componentFileNames = newComponentFileNames;
1093                 }
1094                 // exclusion range limit array length must match component face name
1095                 // array length - native code relies on this
1096 
1097                 int[] clippedExclusionRangeLimits = exclusionRangeLimits;
1098                 if (index != clippedExclusionRangeLimits.length) {
1099                     int len = exclusionRangeLimits.length;
1100                     clippedExclusionRangeLimits = new int[index];
1101                     System.arraycopy(exclusionRangeLimits, 0, clippedExclusionRangeLimits, 0, len);
1102                     //padding for various fallback fonts
1103                     for (int i = len; i < index; i++) {
1104                         clippedExclusionRangeLimits[i] = exclusionRanges.length;
1105                     }
1106                 }
1107                 /*
1108                 System.out.println(faceName + ":");
1109                 for (int i = 0; i < componentFileNames.length; i++) {
1110                     System.out.println("    " + componentFaceNames[i]
1111                          + "  -> " + componentFileNames[i]);
1112                 }
1113                 */
1114                 result[fontIndex * NUM_STYLES + styleIndex]
1115                         = new CompositeFontDescriptor(
1116                             faceName,
1117                             compCoreNum[fontIndex],
1118                             componentFaceNames,
1119                             componentFileNames,
1120                             exclusionRanges,
1121                             clippedExclusionRangeLimits);
1122             }
1123         }
1124         return result;
1125     }
1126 
1127     protected abstract String getFaceNameFromComponentFontName(String componentFontName);
1128     protected abstract String getFileNameFromComponentFontName(String componentFontName);
1129 
1130     /*
1131     public class 2dFont {
1132         public String platformName;
1133         public String fontfileName;
1134     }
1135     private 2dFont [] componentFonts = null;
1136     */
1137 
1138     /* Used on Linux to test if a file referenced in a font configuration
1139      * file exists in the location that is expected. If it does, no need
1140      * to search for it. If it doesn't then unless its a fallback font,
1141      * return that expensive code should be invoked to search for the font.
1142      */
1143     HashMap<String, Boolean> existsMap;
1144     public boolean needToSearchForFile(String fileName) {
1145         if (!FontUtilities.isLinux) {
1146             return false;
1147         } else if (existsMap == null) {
1148            existsMap = new HashMap<String, Boolean>();
1149         }
1150         Boolean exists = existsMap.get(fileName);
1151         if (exists == null) {
1152             /* call getNumberCoreFonts() to ensure these are initialised, and
1153              * if this file isn't for a core component, ie, is a for a fallback
1154              * font which very typically isn't available, then can't afford
1155              * to take the start-up penalty to search for it.
1156              */
1157             getNumberCoreFonts();
1158             if (!coreFontFileNames.contains(fileName)) {
1159                 exists = Boolean.TRUE;
1160             } else {
1161                 exists = Boolean.valueOf((new File(fileName)).exists());
1162                 existsMap.put(fileName, exists);
1163                 if (FontUtilities.debugFonts() &&
1164                     exists == Boolean.FALSE) {
1165                     logger.warning("Couldn't locate font file " + fileName);
1166                 }
1167             }
1168         }
1169         return exists == Boolean.FALSE;
1170     }
1171 
1172     private int numCoreFonts = -1;
1173     private String[] componentFonts = null;
1174     HashMap <String, String> filenamesMap = new HashMap<String, String>();
1175     HashSet <String> coreFontFileNames = new HashSet<String>();
1176 
1177     /* Return the number of core fonts. Note this isn't thread safe but
1178      * a calling thread can call this and getPlatformFontNames() in either
1179      * order.
1180      */
1181     public int getNumberCoreFonts() {
1182         if (numCoreFonts == -1) {
1183             numCoreFonts = coreFontNameIDs.size();
1184             Short[] emptyShortArray = new Short[0];
1185             Short[] core = coreFontNameIDs.toArray(emptyShortArray);
1186             Short[] fallback = fallbackFontNameIDs.toArray(emptyShortArray);
1187 
1188             int numFallbackFonts = 0;
1189             int i;
1190             for (i = 0; i < fallback.length; i++) {
1191                 if (coreFontNameIDs.contains(fallback[i])) {
1192                     fallback[i] = null;
1193                     continue;
1194                 }
1195                 numFallbackFonts++;
1196             }
1197             componentFonts = new String[numCoreFonts + numFallbackFonts];
1198             String filename = null;
1199             for (i = 0; i < core.length; i++) {
1200                 short fontid = core[i];
1201                 short fileid = getComponentFileID(fontid);
1202                 componentFonts[i] = getComponentFontName(fontid);
1203                 String compFileName = getComponentFileName(fileid);
1204                 if (compFileName != null) {
1205                     coreFontFileNames.add(compFileName);
1206                 }
1207                 filenamesMap.put(componentFonts[i], mapFileName(compFileName));
1208             }
1209             for (int j = 0; j < fallback.length; j++) {
1210                 if (fallback[j] != null) {
1211                     short fontid = fallback[j];
1212                     short fileid = getComponentFileID(fontid);
1213                     componentFonts[i] = getComponentFontName(fontid);
1214                     filenamesMap.put(componentFonts[i],
1215                                      mapFileName(getComponentFileName(fileid)));
1216                     i++;
1217                 }
1218             }
1219         }
1220         return numCoreFonts;
1221     }
1222 
1223     /* Return all platform font names used by this font configuration.
1224      * The first getNumberCoreFonts() entries are guaranteed to be the
1225      * core fonts - ie no fall back only fonts.
1226      */
1227     public String[] getPlatformFontNames() {
1228         if (numCoreFonts == -1) {
1229             getNumberCoreFonts();
1230         }
1231         return componentFonts;
1232     }
1233 
1234     /**
1235      * Returns a file name for the physical font represented by this platform font name,
1236      * if the font configuration has such information available, or null if the
1237      * information is unavailable. The file name returned is just a hint; a null return
1238      * value doesn't necessarily mean that the font is unavailable, nor does a non-null
1239      * return value guarantee that the file exists and contains the physical font.
1240      * The file name can be an absolute or a relative path name.
1241      */
1242     public String getFileNameFromPlatformName(String platformName) {
1243         // get2DCompositeFontInfo
1244         //     ->  getFileNameFromComponentfontName()  (W/M)
1245         //       ->   getFileNameFromPlatformName()
1246         // it's a waste of time on Win32, but I have to give X11 a chance to
1247         // call getFileNameFromXLFD()
1248         return filenamesMap.get(platformName);
1249     }
1250 
1251     /**
1252      * Returns a configuration specific path to be appended to the font
1253      * search path.
1254      */
1255     public String getExtraFontPath() {
1256         return getString(head[INDEX_appendedfontpath]);
1257     }
1258 
1259     public String getVersion() {
1260         return getString(head[INDEX_version]);
1261     }
1262 
1263     /* subclass support */
1264     protected static FontConfiguration getFontConfiguration() {
1265         return fontConfig;
1266     }
1267 
1268     protected void setFontConfiguration() {
1269         fontConfig = this;      /* static initialization */
1270     }
1271 
1272     //////////////////////////////////////////////////////////////////////
1273     // FontConfig data tables and the index constants in binary file    //
1274     //////////////////////////////////////////////////////////////////////
1275     /* The binary font configuration file begins with a short[] "head", which
1276      * contains the offsets to the starts of the individual data table which
1277      * immediately follow. The current implementation includes the tables shown
1278      * below.
1279      *
1280      * (00) table_scriptIDs    :stringIDs of all defined CharacterSubsetNames
1281      * (01) table_scriptFonts  :scriptID x fontIndex x styleIndex->
1282      *                          PlatformFontNameID mapping. Each scriptID might
1283      *                          have 1 or 20 entries depends on if it is defined
1284      *                          via a "allfonts.CharacterSubsetname" or a list of
1285      *                          "LogicalFontName.StyleName.CharacterSubsetName"
1286      *                          entries, positive entry means it's a "allfonts"
1287      *                          entry, a negative value means this is a offset to
1288      *                          a NUM_FONTS x NUM_STYLES subtable.
1289      * (02) table_elcIDs       :stringIDs of all defined ELC names, string
1290      *                          "NULL.NULL.NULL" is used for "default"
1291      * (03) table_sequences    :elcID x logicalFont -> scriptIDs table defined
1292      *                          by "sequence.allfonts/LogicalFontName.ELC" in
1293      *                          font configuration file, each "elcID" has
1294      *                          NUM_FONTS (5) entries in this table.
1295      * (04) table_fontfileNameIDs
1296      *                         :stringIDs of all defined font file names
1297      * (05) table_componentFontNameIDs
1298      *                         :stringIDs of all defined PlatformFontNames
1299      * (06) table_filenames    :platformFontNamesID->fontfileNameID mapping
1300      *                          table, the index is the platformFontNamesID.
1301      * (07) table_awtfontpaths :CharacterSubsetNames->awtfontpaths mapping table,
1302      *                          the index is the CharacterSubsetName's stringID
1303      *                          and content is the stringID of awtfontpath.
1304      * (08) table_exclusions   :scriptID -> exclusionRanges mapping table,
1305      *                          the index is the scriptID and the content is
1306                                 a id of an exclusionRanges int[].
1307      * (09) table_proportionals:list of pairs of PlatformFontNameIDs, stores
1308      *                          the replacement info defined by "proportional"
1309      *                          keyword.
1310      * (10) table_scriptFontsMotif
1311      *                         :same as (01) except this table stores the
1312      *                          info defined with ".motif" keyword
1313      * (11) table_alphabeticSuffix
1314      *                         :elcID -> stringID of alphabetic/XXXX entries
1315      * (12) table_stringIDs    :The index of this table is the string ID, the
1316      *                          content is the "start index" of this string in
1317      *                          stringTable, use the start index of next entry
1318      *                          as the "end index".
1319      * (13) table_stringTable  :The real storage of all character strings defined
1320      *                          /used this font configuration, need a pair of
1321      *                          "start" and "end" indices to access.
1322      * (14) reserved
1323      * (15) table_fallbackScripts
1324      *                         :stringIDs of fallback CharacterSubsetnames, stored
1325      *                          in the order of they are defined in sequence.fallback.
1326      * (16) table_appendedfontpath
1327      *                         :stringtID of the "appendedfontpath" defined.
1328      * (17) table_version   :stringID of the version number of this fontconfig file.
1329      */
1330     private static final int HEAD_LENGTH = 20;
1331     private static final int INDEX_scriptIDs = 0;
1332     private static final int INDEX_scriptFonts = 1;
1333     private static final int INDEX_elcIDs = 2;
1334     private static final int INDEX_sequences = 3;
1335     private static final int INDEX_fontfileNameIDs = 4;
1336     private static final int INDEX_componentFontNameIDs = 5;
1337     private static final int INDEX_filenames = 6;
1338     private static final int INDEX_awtfontpaths = 7;
1339     private static final int INDEX_exclusions = 8;
1340     private static final int INDEX_proportionals = 9;
1341     private static final int INDEX_scriptFontsMotif = 10;
1342     private static final int INDEX_alphabeticSuffix = 11;
1343     private static final int INDEX_stringIDs = 12;
1344     private static final int INDEX_stringTable = 13;
1345     private static final int INDEX_TABLEEND = 14;
1346     private static final int INDEX_fallbackScripts = 15;
1347     private static final int INDEX_appendedfontpath = 16;
1348     private static final int INDEX_version = 17;
1349 
1350     private static short[] head;
1351     private static short[] table_scriptIDs;
1352     private static short[] table_scriptFonts;
1353     private static short[] table_elcIDs;
1354     private static short[] table_sequences;
1355     private static short[] table_fontfileNameIDs;
1356     private static short[] table_componentFontNameIDs;
1357     private static short[] table_filenames;
1358     protected static short[] table_awtfontpaths;
1359     private static short[] table_exclusions;
1360     private static short[] table_proportionals;
1361     private static short[] table_scriptFontsMotif;
1362     private static short[] table_alphabeticSuffix;
1363     private static short[] table_stringIDs;
1364     private static char[]  table_stringTable;
1365 
1366     /**
1367      * Checks consistencies of complied fontconfig data. This method
1368      * is called only at the build-time from
1369      * build.tools.compilefontconfig.CompileFontConfig.
1370      */
1371     private static void sanityCheck() {
1372         int errors = 0;
1373 
1374         //This method will only be called during build time, do we
1375         //need do PrivilegedAction?
1376         String osName = java.security.AccessController.doPrivileged(
1377                             new java.security.PrivilegedAction<String>() {
1378             public String run() {
1379                 return System.getProperty("os.name");
1380             }
1381         });
1382 
1383         //componentFontNameID starts from "1"
1384         for (int ii = 1; ii < table_filenames.length; ii++) {
1385             if (table_filenames[ii] == -1) {
1386                 // The corresponding finename entry for a component
1387                 // font name is mandatory on Windows, but it's
1388                 // optional on Solaris and Linux.
1389                 if (osName.contains("Windows")) {
1390                     System.err.println("\n Error: <filename."
1391                                        + getString(table_componentFontNameIDs[ii])
1392                                        + "> entry is missing!!!");
1393                     errors++;
1394                 } else {
1395                     if (verbose && !isEmpty(table_filenames)) {
1396                         System.err.println("\n Note: 'filename' entry is undefined for \""
1397                                            + getString(table_componentFontNameIDs[ii])
1398                                            + "\"");
1399                     }
1400                 }
1401             }
1402         }
1403         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1404             short fid = table_scriptFonts[ii];
1405             if (fid == 0) {
1406                 System.out.println("\n Error: <allfonts."
1407                                    + getString(table_scriptIDs[ii])
1408                                    + "> entry is missing!!!");
1409                 errors++;
1410                 continue;
1411             } else if (fid < 0) {
1412                 fid = (short)-fid;
1413                 for (int iii = 0; iii < NUM_FONTS; iii++) {
1414                     for (int iij = 0; iij < NUM_STYLES; iij++) {
1415                         int jj = iii * NUM_STYLES + iij;
1416                         short ffid = table_scriptFonts[fid + jj];
1417                         if (ffid == 0) {
1418                             System.err.println("\n Error: <"
1419                                            + getFontName(iii) + "."
1420                                            + getStyleName(iij) + "."
1421                                            + getString(table_scriptIDs[ii])
1422                                            + "> entry is missing!!!");
1423                             errors++;
1424                         }
1425                     }
1426                 }
1427             }
1428         }
1429         if (errors != 0) {
1430             System.err.println("!!THERE ARE " + errors + " ERROR(S) IN "
1431                                + "THE FONTCONFIG FILE, PLEASE CHECK ITS CONTENT!!\n");
1432             System.exit(1);
1433         }
1434     }
1435 
1436     private static boolean isEmpty(short[] a) {
1437         for (short s : a) {
1438             if (s != -1) {
1439                 return false;
1440             }
1441         }
1442         return true;
1443     }
1444 
1445     //dump the fontconfig data tables
1446     private static void dump() {
1447         System.out.println("\n----Head Table------------");
1448         for (int ii = 0; ii < HEAD_LENGTH; ii++) {
1449             System.out.println("  " + ii + " : " + head[ii]);
1450         }
1451         System.out.println("\n----scriptIDs-------------");
1452         printTable(table_scriptIDs, 0);
1453         System.out.println("\n----scriptFonts----------------");
1454         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1455             short fid = table_scriptFonts[ii];
1456             if (fid >= 0) {
1457                 System.out.println("  allfonts."
1458                                    + getString(table_scriptIDs[ii])
1459                                    + "="
1460                                    + getString(table_componentFontNameIDs[fid]));
1461             }
1462         }
1463         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1464             short fid = table_scriptFonts[ii];
1465             if (fid < 0) {
1466                 fid = (short)-fid;
1467                 for (int iii = 0; iii < NUM_FONTS; iii++) {
1468                     for (int iij = 0; iij < NUM_STYLES; iij++) {
1469                         int jj = iii * NUM_STYLES + iij;
1470                         short ffid = table_scriptFonts[fid + jj];
1471                         System.out.println("  "
1472                                            + getFontName(iii) + "."
1473                                            + getStyleName(iij) + "."
1474                                            + getString(table_scriptIDs[ii])
1475                                            + "="
1476                                            + getString(table_componentFontNameIDs[ffid]));
1477                     }
1478                 }
1479 
1480             }
1481         }
1482         System.out.println("\n----elcIDs----------------");
1483         printTable(table_elcIDs, 0);
1484         System.out.println("\n----sequences-------------");
1485         for (int ii = 0; ii< table_elcIDs.length; ii++) {
1486             System.out.println("  " + ii + "/" + getString(table_elcIDs[ii]));
1487             short[] ss = getShortArray(table_sequences[ii * NUM_FONTS + 0]);
1488             for (int jj = 0; jj < ss.length; jj++) {
1489                 System.out.println("     " + getString(table_scriptIDs[ss[jj]]));
1490             }
1491         }
1492         System.out.println("\n----fontfileNameIDs-------");
1493         printTable(table_fontfileNameIDs, 0);
1494 
1495         System.out.println("\n----componentFontNameIDs--");
1496         printTable(table_componentFontNameIDs, 1);
1497         System.out.println("\n----filenames-------------");
1498         for (int ii = 0; ii < table_filenames.length; ii++) {
1499             if (table_filenames[ii] == -1) {
1500                 System.out.println("  " + ii + " : null");
1501             } else {
1502                 System.out.println("  " + ii + " : "
1503                    + getString(table_fontfileNameIDs[table_filenames[ii]]));
1504             }
1505         }
1506         System.out.println("\n----awtfontpaths---------");
1507         for (int ii = 0; ii < table_awtfontpaths.length; ii++) {
1508             System.out.println("  " + getString(table_scriptIDs[ii])
1509                                + " : "
1510                                + getString(table_awtfontpaths[ii]));
1511         }
1512         System.out.println("\n----proportionals--------");
1513         for (int ii = 0; ii < table_proportionals.length; ii++) {
1514             System.out.println("  "
1515                    + getString(table_componentFontNameIDs[table_proportionals[ii++]])
1516                    + " -> "
1517                    + getString(table_componentFontNameIDs[table_proportionals[ii]]));
1518         }
1519         int i = 0;
1520         System.out.println("\n----alphabeticSuffix----");
1521         while (i < table_alphabeticSuffix.length) {
1522           System.out.println("    " + getString(table_elcIDs[table_alphabeticSuffix[i++]])
1523                              + " -> " + getString(table_alphabeticSuffix[i++]));
1524         }
1525         System.out.println("\n----String Table---------");
1526         System.out.println("    stringID:    Num =" + table_stringIDs.length);
1527         System.out.println("    stringTable: Size=" + table_stringTable.length * 2);
1528 
1529         System.out.println("\n----fallbackScriptIDs---");
1530         short[] fbsIDs = getShortArray(head[INDEX_fallbackScripts]);
1531         for (int ii = 0; ii < fbsIDs.length; ii++) {
1532           System.out.println("  " + getString(table_scriptIDs[fbsIDs[ii]]));
1533         }
1534         System.out.println("\n----appendedfontpath-----");
1535         System.out.println("  " + getString(head[INDEX_appendedfontpath]));
1536         System.out.println("\n----Version--------------");
1537         System.out.println("  " + getString(head[INDEX_version]));
1538     }
1539 
1540 
1541     //////////////////////////////////////////////////////////////////////
1542     // Data table access methods                                        //
1543     //////////////////////////////////////////////////////////////////////
1544 
1545     /* Return the fontID of the platformFontName defined in this font config
1546      * by "LogicalFontName.StyleName.CharacterSubsetName" entry or
1547      * "allfonts.CharacterSubsetName" entry in properties format fc file.
1548      */
1549     protected static short getComponentFontID(short scriptID, int fontIndex, int styleIndex) {
1550         short fid = table_scriptFonts[scriptID];
1551         //System.out.println("fid=" + fid + "/ scriptID=" + scriptID + ", fi=" + fontIndex + ", si=" + styleIndex);
1552         if (fid >= 0) {
1553             //"allfonts"
1554             return fid;
1555         } else {
1556             return table_scriptFonts[-fid + fontIndex * NUM_STYLES + styleIndex];
1557         }
1558     }
1559 
1560     /* Same as getCompoentFontID() except this method returns the fontID define by
1561      * "xxxx.motif" entry.
1562      */
1563     protected static short getComponentFontIDMotif(short scriptID, int fontIndex, int styleIndex) {
1564         if (table_scriptFontsMotif.length == 0) {
1565             return 0;
1566         }
1567         short fid = table_scriptFontsMotif[scriptID];
1568         if (fid >= 0) {
1569             //"allfonts" > 0 or "not defined" == 0
1570             return fid;
1571         } else {
1572             return table_scriptFontsMotif[-fid + fontIndex * NUM_STYLES + styleIndex];
1573         }
1574     }
1575 
1576     private static int[] getExclusionRanges(short scriptID) {
1577         short exID = table_exclusions[scriptID];
1578         if (exID == 0) {
1579             return EMPTY_INT_ARRAY;
1580         } else {
1581             char[] exChar = getString(exID).toCharArray();
1582             int[] exInt = new int[exChar.length / 2];
1583             int i = 0;
1584             for (int j = 0; j < exInt.length; j++) {
1585                 exInt[j] = (exChar[i++] << 16) + (exChar[i++] & 0xffff);
1586             }
1587             return exInt;
1588         }
1589     }
1590 
1591     private static boolean contains(short[] IDs, short id, int limit) {
1592         for (int i = 0; i < limit; i++) {
1593             if (IDs[i] == id) {
1594                 return true;
1595             }
1596         }
1597         return false;
1598     }
1599 
1600     /* Return the PlatformFontName from its fontID*/
1601     protected static String getComponentFontName(short id) {
1602         if (id < 0) {
1603             return null;
1604         }
1605         return getString(table_componentFontNameIDs[id]);
1606     }
1607 
1608     private static String getComponentFileName(short id) {
1609         if (id < 0) {
1610             return null;
1611         }
1612         return getString(table_fontfileNameIDs[id]);
1613     }
1614 
1615     //componentFontID -> componentFileID
1616     private static short getComponentFileID(short nameID) {
1617         return table_filenames[nameID];
1618     }
1619 
1620     private static String getScriptName(short scriptID) {
1621         return getString(table_scriptIDs[scriptID]);
1622     }
1623 
1624    private HashMap<String, Short> reorderScripts;
1625    protected short[] getCoreScripts(int fontIndex) {
1626         short elc = getInitELC();
1627         /*
1628           System.out.println("getCoreScripts: elc=" + elc + ", fontIndex=" + fontIndex);
1629           short[] ss = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]);
1630           for (int i = 0; i < ss.length; i++) {
1631               System.out.println("     " + getString((short)table_scriptIDs[ss[i]]));
1632           }
1633           */
1634         short[] scripts = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]);
1635         if (preferLocaleFonts) {
1636             if (reorderScripts == null) {
1637                 reorderScripts = new HashMap<String, Short>();
1638             }
1639             String[] ss = new String[scripts.length];
1640             for (int i = 0; i < ss.length; i++) {
1641                 ss[i] = getScriptName(scripts[i]);
1642                 reorderScripts.put(ss[i], scripts[i]);
1643             }
1644             reorderSequenceForLocale(ss);
1645             for (int i = 0; i < ss.length; i++) {
1646                 scripts[i] = reorderScripts.get(ss[i]);
1647             }
1648         }
1649          return scripts;
1650     }
1651 
1652     private static short[] getFallbackScripts() {
1653         return getShortArray(head[INDEX_fallbackScripts]);
1654     }
1655 
1656     private static void printTable(short[] list, int start) {
1657         for (int i = start; i < list.length; i++) {
1658             System.out.println("  " + i + " : " + getString(list[i]));
1659         }
1660     }
1661 
1662     private static short[] readShortTable(DataInputStream in, int len )
1663         throws IOException {
1664         if (len == 0) {
1665             return EMPTY_SHORT_ARRAY;
1666         }
1667         short[] data = new short[len];
1668         byte[] bb = new byte[len * 2];
1669         in.read(bb);
1670         int i = 0,j = 0;
1671         while (i < len) {
1672             data[i++] = (short)(bb[j++] << 8 | (bb[j++] & 0xff));
1673         }
1674         return data;
1675     }
1676 
1677     private static void writeShortTable(DataOutputStream out, short[] data)
1678         throws IOException {
1679         for (short val : data) {
1680             out.writeShort(val);
1681         }
1682     }
1683 
1684     private static short[] toList(HashMap<String, Short> map) {
1685         short[] list = new short[map.size()];
1686         Arrays.fill(list, (short) -1);
1687         for (Entry<String, Short> entry : map.entrySet()) {
1688             list[entry.getValue()] = getStringID(entry.getKey());
1689         }
1690         return list;
1691     }
1692 
1693     //runtime cache
1694     private static String[] stringCache;
1695     protected static String getString(short stringID) {
1696         if (stringID == 0)
1697             return null;
1698         /*
1699         if (loadingProperties) {
1700             return stringTable.substring(stringIDs[stringID],
1701                                          stringIDs[stringID+1]);
1702         }
1703         */
1704         //sync if we want it to be MT-enabled
1705         if (stringCache[stringID] == null){
1706             stringCache[stringID] =
1707               new String (table_stringTable,
1708                           table_stringIDs[stringID],
1709                           table_stringIDs[stringID+1] - table_stringIDs[stringID]);
1710         }
1711         return stringCache[stringID];
1712     }
1713 
1714     private static short[] getShortArray(short shortArrayID) {
1715         String s = getString(shortArrayID);
1716         char[] cc = s.toCharArray();
1717         short[] ss = new short[cc.length];
1718         for (int i = 0; i < cc.length; i++) {
1719             ss[i] = (short)(cc[i] & 0xffff);
1720         }
1721         return ss;
1722     }
1723 
1724     private static short getStringID(String s) {
1725         if (s == null) {
1726             return (short)0;
1727         }
1728         short pos0 = (short)stringTable.length();
1729         stringTable.append(s);
1730         short pos1 = (short)stringTable.length();
1731 
1732         stringIDs[stringIDNum] = pos0;
1733         stringIDs[stringIDNum + 1] = pos1;
1734         stringIDNum++;
1735         if (stringIDNum + 1 >= stringIDs.length) {
1736             short[] tmp = new short[stringIDNum + 1000];
1737             System.arraycopy(stringIDs, 0, tmp, 0, stringIDNum);
1738             stringIDs = tmp;
1739         }
1740         return (short)(stringIDNum - 1);
1741     }
1742 
1743     private static short getShortArrayID(short[] sa) {
1744         char[] cc = new char[sa.length];
1745         for (int i = 0; i < sa.length; i ++) {
1746             cc[i] = (char)sa[i];
1747         }
1748         String s = new String(cc);
1749         return getStringID(s);
1750     }
1751 
1752     //utility "empty" objects
1753     private static final int[] EMPTY_INT_ARRAY = new int[0];
1754     private static final String[] EMPTY_STRING_ARRAY = new String[0];
1755     private static final short[] EMPTY_SHORT_ARRAY = new short[0];
1756     private static final String UNDEFINED_COMPONENT_FONT = "unknown";
1757 
1758     //////////////////////////////////////////////////////////////////////////
1759     //Convert the FontConfig data in Properties file to binary data tables  //
1760     //////////////////////////////////////////////////////////////////////////
1761     static class PropertiesHandler {
1762         public void load(InputStream in) throws IOException {
1763             initLogicalNameStyle();
1764             initHashMaps();
1765             FontProperties fp = new FontProperties();
1766             fp.load(in);
1767             initBinaryTable();
1768         }
1769 
1770         private void initBinaryTable() {
1771             //(0)
1772             head = new short[HEAD_LENGTH];
1773             head[INDEX_scriptIDs] = (short)HEAD_LENGTH;
1774 
1775             table_scriptIDs = toList(scriptIDs);
1776             //(1)a: scriptAllfonts scriptID/allfonts -> componentFontNameID
1777             //   b: scriptFonts    scriptID -> componentFontNameID[20]
1778             //if we have a "allfonts.script" def, then we just put
1779             //the "-platformFontID" value in the slot, otherwise the slot
1780             //value is "offset" which "offset" is where 20 entries located
1781             //in the table attached.
1782             head[INDEX_scriptFonts] = (short)(head[INDEX_scriptIDs]  + table_scriptIDs.length);
1783             int len = table_scriptIDs.length + scriptFonts.size() * 20;
1784             table_scriptFonts = new short[len];
1785 
1786             for (Entry<Short, Short> entry : scriptAllfonts.entrySet()) {
1787                 table_scriptFonts[entry.getKey().intValue()] = entry.getValue();
1788             }
1789             int off = table_scriptIDs.length;
1790             for (Entry<Short, Short[]> entry : scriptFonts.entrySet()) {
1791                 table_scriptFonts[entry.getKey().intValue()] = (short)-off;
1792                 Short[] v = entry.getValue();
1793                 for (int i = 0; i < 20; i++) {
1794                     if (v[i] != null) {
1795                         table_scriptFonts[off++] = v[i];
1796                     } else {
1797                         table_scriptFonts[off++] = 0;
1798                     }
1799                 }
1800             }
1801 
1802             //(2)
1803             head[INDEX_elcIDs] = (short)(head[INDEX_scriptFonts]  + table_scriptFonts.length);
1804             table_elcIDs = toList(elcIDs);
1805 
1806             //(3) sequences  elcID -> XXXX[1|5] -> scriptID[]
1807             head[INDEX_sequences] = (short)(head[INDEX_elcIDs]  + table_elcIDs.length);
1808             table_sequences = new short[elcIDs.size() * NUM_FONTS];
1809             for (Entry<Short, short[]> entry : sequences.entrySet()) {
1810                 //table_sequences[entry.getKey().intValue()] = (short)-off;
1811                 int k = entry.getKey().intValue();
1812                 short[] v = entry.getValue();
1813                 /*
1814                   System.out.println("elc=" + k + "/" + getString((short)table_elcIDs[k]));
1815                   short[] ss = getShortArray(v[0]);
1816                   for (int i = 0; i < ss.length; i++) {
1817                   System.out.println("     " + getString((short)table_scriptIDs[ss[i]]));
1818                   }
1819                   */
1820                 if (v.length == 1) {
1821                     //the "allfonts" entries
1822                     for (int i = 0; i < NUM_FONTS; i++) {
1823                         table_sequences[k * NUM_FONTS + i] = v[0];
1824                     }
1825                 } else {
1826                     for (int i = 0; i < NUM_FONTS; i++) {
1827                         table_sequences[k * NUM_FONTS + i] = v[i];
1828                     }
1829                 }
1830             }
1831             //(4)
1832             head[INDEX_fontfileNameIDs] = (short)(head[INDEX_sequences]  + table_sequences.length);
1833             table_fontfileNameIDs = toList(fontfileNameIDs);
1834 
1835             //(5)
1836             head[INDEX_componentFontNameIDs] = (short)(head[INDEX_fontfileNameIDs]  + table_fontfileNameIDs.length);
1837             table_componentFontNameIDs = toList(componentFontNameIDs);
1838 
1839             //(6)componentFontNameID -> filenameID
1840             head[INDEX_filenames] = (short)(head[INDEX_componentFontNameIDs]  + table_componentFontNameIDs.length);
1841             table_filenames = new short[table_componentFontNameIDs.length];
1842             Arrays.fill(table_filenames, (short) -1);
1843 
1844             for (Entry<Short, Short> entry : filenames.entrySet()) {
1845                 table_filenames[entry.getKey()] = entry.getValue();
1846             }
1847 
1848             //(7)scriptID-> awtfontpath
1849             //the paths are stored as scriptID -> stringID in awtfontpahts
1850             head[INDEX_awtfontpaths] = (short)(head[INDEX_filenames]  + table_filenames.length);
1851             table_awtfontpaths = new short[table_scriptIDs.length];
1852             for (Entry<Short, Short> entry : awtfontpaths.entrySet()) {
1853                 table_awtfontpaths[entry.getKey()] = entry.getValue();
1854             }
1855 
1856             //(8)exclusions
1857             head[INDEX_exclusions] = (short)(head[INDEX_awtfontpaths]  + table_awtfontpaths.length);
1858             table_exclusions = new short[scriptIDs.size()];
1859             for (Entry<Short, int[]> entry : exclusions.entrySet()) {
1860                 int[] exI = entry.getValue();
1861                 char[] exC = new char[exI.length * 2];
1862                 int j = 0;
1863                 for (int i = 0; i < exI.length; i++) {
1864                     exC[j++] = (char) (exI[i] >> 16);
1865                     exC[j++] = (char) (exI[i] & 0xffff);
1866                 }
1867                 table_exclusions[entry.getKey()] = getStringID(new String (exC));
1868             }
1869             //(9)proportionals
1870             head[INDEX_proportionals] = (short)(head[INDEX_exclusions]  + table_exclusions.length);
1871             table_proportionals = new short[proportionals.size() * 2];
1872             int j = 0;
1873             for (Entry<Short, Short> entry : proportionals.entrySet()) {
1874                 table_proportionals[j++] = entry.getKey();
1875                 table_proportionals[j++] = entry.getValue();
1876             }
1877 
1878             //(10) see (1) for info, the only difference is "xxx.motif"
1879             head[INDEX_scriptFontsMotif] = (short)(head[INDEX_proportionals] + table_proportionals.length);
1880             if (scriptAllfontsMotif.size() != 0 || scriptFontsMotif.size() != 0) {
1881                 len = table_scriptIDs.length + scriptFontsMotif.size() * 20;
1882                 table_scriptFontsMotif = new short[len];
1883 
1884                 for (Entry<Short, Short> entry : scriptAllfontsMotif.entrySet()) {
1885                     table_scriptFontsMotif[entry.getKey().intValue()] =
1886                       (short)entry.getValue();
1887                 }
1888                 off = table_scriptIDs.length;
1889                 for (Entry<Short, Short[]> entry : scriptFontsMotif.entrySet()) {
1890                     table_scriptFontsMotif[entry.getKey().intValue()] = (short)-off;
1891                     Short[] v = entry.getValue();
1892                     int i = 0;
1893                     while (i < 20) {
1894                         if (v[i] != null) {
1895                             table_scriptFontsMotif[off++] = v[i];
1896                         } else {
1897                             table_scriptFontsMotif[off++] = 0;
1898                         }
1899                         i++;
1900                     }
1901                 }
1902             } else {
1903                 table_scriptFontsMotif = EMPTY_SHORT_ARRAY;
1904             }
1905 
1906             //(11)short[] alphabeticSuffix
1907             head[INDEX_alphabeticSuffix] = (short)(head[INDEX_scriptFontsMotif] + table_scriptFontsMotif.length);
1908             table_alphabeticSuffix = new short[alphabeticSuffix.size() * 2];
1909             j = 0;
1910             for (Entry<Short, Short> entry : alphabeticSuffix.entrySet()) {
1911                 table_alphabeticSuffix[j++] = entry.getKey();
1912                 table_alphabeticSuffix[j++] = entry.getValue();
1913             }
1914 
1915             //(15)short[] fallbackScriptIDs; just put the ID in head
1916             head[INDEX_fallbackScripts] = getShortArrayID(fallbackScriptIDs);
1917 
1918             //(16)appendedfontpath
1919             head[INDEX_appendedfontpath] = getStringID(appendedfontpath);
1920 
1921             //(17)version
1922             head[INDEX_version] = getStringID(version);
1923 
1924             //(12)short[] StringIDs
1925             head[INDEX_stringIDs] = (short)(head[INDEX_alphabeticSuffix] + table_alphabeticSuffix.length);
1926             table_stringIDs = new short[stringIDNum + 1];
1927             System.arraycopy(stringIDs, 0, table_stringIDs, 0, stringIDNum + 1);
1928 
1929             //(13)StringTable
1930             head[INDEX_stringTable] = (short)(head[INDEX_stringIDs] + stringIDNum + 1);
1931             table_stringTable = stringTable.toString().toCharArray();
1932             //(14)
1933             head[INDEX_TABLEEND] = (short)(head[INDEX_stringTable] + stringTable.length());
1934 
1935             //StringTable cache
1936             stringCache = new String[table_stringIDs.length];
1937         }
1938 
1939         //////////////////////////////////////////////
1940         private HashMap<String, Short> scriptIDs;
1941         //elc -> Encoding.Language.Country
1942         private HashMap<String, Short> elcIDs;
1943         //componentFontNameID starts from "1", "0" reserves for "undefined"
1944         private HashMap<String, Short> componentFontNameIDs;
1945         private HashMap<String, Short> fontfileNameIDs;
1946         private HashMap<String, Integer> logicalFontIDs;
1947         private HashMap<String, Integer> fontStyleIDs;
1948 
1949         //componentFontNameID -> fontfileNameID
1950         private HashMap<Short, Short>  filenames;
1951 
1952         //elcID -> allfonts/logicalFont -> scriptID list
1953         //(1)if we have a "allfonts", then the length of the
1954         //   value array is "1", otherwise it's 5, each font
1955         //   must have their own individual entry.
1956         //scriptID list "short[]" is stored as an ID
1957         private HashMap<Short, short[]> sequences;
1958 
1959         //scriptID ->logicFontID/fontStyleID->componentFontNameID,
1960         //a 20-entry array (5-name x 4-style) for each script
1961         private HashMap<Short, Short[]> scriptFonts;
1962 
1963         //scriptID -> componentFontNameID
1964         private HashMap<Short, Short> scriptAllfonts;
1965 
1966         //scriptID -> exclusionRanges[]
1967         private HashMap<Short, int[]> exclusions;
1968 
1969         //scriptID -> fontpath
1970         private HashMap<Short, Short> awtfontpaths;
1971 
1972         //fontID -> fontID
1973         private HashMap<Short, Short> proportionals;
1974 
1975         //scriptID -> componentFontNameID
1976         private HashMap<Short, Short> scriptAllfontsMotif;
1977 
1978         //scriptID ->logicFontID/fontStyleID->componentFontNameID,
1979         private HashMap<Short, Short[]> scriptFontsMotif;
1980 
1981         //elcID -> stringID of alphabetic/XXXX
1982         private HashMap<Short, Short> alphabeticSuffix;
1983 
1984         private short[] fallbackScriptIDs;
1985         private String version;
1986         private String appendedfontpath;
1987 
1988         private void initLogicalNameStyle() {
1989             logicalFontIDs = new HashMap<String, Integer>();
1990             fontStyleIDs = new HashMap<String, Integer>();
1991             logicalFontIDs.put("serif",      0);
1992             logicalFontIDs.put("sansserif",  1);
1993             logicalFontIDs.put("monospaced", 2);
1994             logicalFontIDs.put("dialog",     3);
1995             logicalFontIDs.put("dialoginput",4);
1996             fontStyleIDs.put("plain",      0);
1997             fontStyleIDs.put("bold",       1);
1998             fontStyleIDs.put("italic",     2);
1999             fontStyleIDs.put("bolditalic", 3);
2000         }
2001 
2002         private void initHashMaps() {
2003             scriptIDs = new HashMap<String, Short>();
2004             elcIDs = new HashMap<String, Short>();
2005             componentFontNameIDs = new HashMap<String, Short>();
2006             /*Init these tables to allow componentFontNameID, fontfileNameIDs
2007               to start from "1".
2008             */
2009             componentFontNameIDs.put("", Short.valueOf((short)0));
2010 
2011             fontfileNameIDs = new HashMap<String, Short>();
2012             filenames = new HashMap<Short, Short>();
2013             sequences = new HashMap<Short, short[]>();
2014             scriptFonts = new HashMap<Short, Short[]>();
2015             scriptAllfonts = new HashMap<Short, Short>();
2016             exclusions = new HashMap<Short, int[]>();
2017             awtfontpaths = new HashMap<Short, Short>();
2018             proportionals = new HashMap<Short, Short>();
2019             scriptFontsMotif = new HashMap<Short, Short[]>();
2020             scriptAllfontsMotif = new HashMap<Short, Short>();
2021             alphabeticSuffix = new HashMap<Short, Short>();
2022             fallbackScriptIDs = EMPTY_SHORT_ARRAY;
2023             /*
2024               version
2025               appendedfontpath
2026             */
2027         }
2028 
2029         private int[] parseExclusions(String key, String exclusions) {
2030             if (exclusions == null) {
2031                 return EMPTY_INT_ARRAY;
2032             }
2033             // range format is xxxx-XXXX,yyyyyy-YYYYYY,.....
2034             int numExclusions = 1;
2035             int pos = 0;
2036             while ((pos = exclusions.indexOf(',', pos)) != -1) {
2037                 numExclusions++;
2038                 pos++;
2039             }
2040             int[] exclusionRanges = new int[numExclusions * 2];
2041             pos = 0;
2042             int newPos = 0;
2043             for (int j = 0; j < numExclusions * 2; ) {
2044                 String lower, upper;
2045                 int lo = 0, up = 0;
2046                 try {
2047                     newPos = exclusions.indexOf('-', pos);
2048                     lower = exclusions.substring(pos, newPos);
2049                     pos = newPos + 1;
2050                     newPos = exclusions.indexOf(',', pos);
2051                     if (newPos == -1) {
2052                         newPos = exclusions.length();
2053                     }
2054                     upper = exclusions.substring(pos, newPos);
2055                     pos = newPos + 1;
2056                     int lowerLength = lower.length();
2057                     int upperLength = upper.length();
2058                     if (lowerLength != 4 && lowerLength != 6
2059                         || upperLength != 4 && upperLength != 6) {
2060                         throw new Exception();
2061                     }
2062                     lo = Integer.parseInt(lower, 16);
2063                     up = Integer.parseInt(upper, 16);
2064                     if (lo > up) {
2065                         throw new Exception();
2066                     }
2067                 } catch (Exception e) {
2068                     if (FontUtilities.debugFonts() &&
2069                         logger != null) {
2070                         logger.config("Failed parsing " + key +
2071                                   " property of font configuration.");
2072 
2073                     }
2074                     return EMPTY_INT_ARRAY;
2075                 }
2076                 exclusionRanges[j++] = lo;
2077                 exclusionRanges[j++] = up;
2078             }
2079             return exclusionRanges;
2080         }
2081 
2082         private Short getID(HashMap<String, Short> map, String key) {
2083             Short ret = map.get(key);
2084             if ( ret == null) {
2085                 map.put(key, (short)map.size());
2086                 return map.get(key);
2087             }
2088             return ret;
2089         }
2090 
2091         @SuppressWarnings("serial") // JDK-implementation class
2092         class FontProperties extends Properties {
2093             public synchronized Object put(Object k, Object v) {
2094                 parseProperty((String)k, (String)v);
2095                 return null;
2096             }
2097         }
2098 
2099         private void parseProperty(String key, String value) {
2100             if (key.startsWith("filename.")) {
2101                 //the only special case is "MingLiu_HKSCS" which has "_" in its
2102                 //facename, we don't want to replace the "_" with " "
2103                 key = key.substring(9);
2104                 if (!"MingLiU_HKSCS".equals(key)) {
2105                     key = key.replace('_', ' ');
2106                 }
2107                 Short faceID = getID(componentFontNameIDs, key);
2108                 Short fileID = getID(fontfileNameIDs, value);
2109                 //System.out.println("faceID=" + faceID + "/" + key + " -> "
2110                 //    + "fileID=" + fileID + "/" + value);
2111                 filenames.put(faceID, fileID);
2112             } else if (key.startsWith("exclusion.")) {
2113                 key = key.substring(10);
2114                 exclusions.put(getID(scriptIDs,key), parseExclusions(key,value));
2115             } else if (key.startsWith("sequence.")) {
2116                 key = key.substring(9);
2117                 boolean hasDefault = false;
2118                 boolean has1252 = false;
2119 
2120                 //get the scriptID list
2121                 String[] ss = splitSequence(value).toArray(EMPTY_STRING_ARRAY);
2122                 short [] sa = new short[ss.length];
2123                 for (int i = 0; i < ss.length; i++) {
2124                     if ("alphabetic/default".equals(ss[i])) {
2125                         //System.out.println(key + " -> " + ss[i]);
2126                         ss[i] = "alphabetic";
2127                         hasDefault = true;
2128                     } else if ("alphabetic/1252".equals(ss[i])) {
2129                         //System.out.println(key + " -> " + ss[i]);
2130                         ss[i] = "alphabetic";
2131                         has1252 = true;
2132                     }
2133                     sa[i] = getID(scriptIDs, ss[i]).shortValue();
2134                     //System.out.println("scriptID=" + si[i] + "/" + ss[i]);
2135                 }
2136                 //convert the "short[] -> string -> stringID"
2137                 short scriptArrayID = getShortArrayID(sa);
2138                 Short elcID = null;
2139                 int dot = key.indexOf('.');
2140                 if (dot == -1) {
2141                     if ("fallback".equals(key)) {
2142                         fallbackScriptIDs = sa;
2143                         return;
2144                     }
2145                     if ("allfonts".equals(key)) {
2146                         elcID = getID(elcIDs, "NULL.NULL.NULL");
2147                     } else {
2148                         if (logger != null) {
2149                             logger.config("Error sequence def: <sequence." + key + ">");
2150                         }
2151                         return;
2152                     }
2153                 } else {
2154                     elcID = getID(elcIDs, key.substring(dot + 1));
2155                     //System.out.println("elcID=" + elcID + "/" + key.substring(dot + 1));
2156                     key = key.substring(0, dot);
2157                 }
2158                 short[] scriptArrayIDs = null;
2159                 if ("allfonts".equals(key)) {
2160                     scriptArrayIDs = new short[1];
2161                     scriptArrayIDs[0] = scriptArrayID;
2162                 } else {
2163                     scriptArrayIDs = sequences.get(elcID);
2164                     if (scriptArrayIDs == null) {
2165                        scriptArrayIDs = new short[5];
2166                     }
2167                     Integer fid = logicalFontIDs.get(key);
2168                     if (fid == null) {
2169                         if (logger != null) {
2170                             logger.config("Unrecognizable logicfont name " + key);
2171                         }
2172                         return;
2173                     }
2174                     //System.out.println("sequence." + key + "/" + id);
2175                     scriptArrayIDs[fid.intValue()] = scriptArrayID;
2176                 }
2177                 sequences.put(elcID, scriptArrayIDs);
2178                 if (hasDefault) {
2179                     alphabeticSuffix.put(elcID, getStringID("default"));
2180                 } else
2181                 if (has1252) {
2182                     alphabeticSuffix.put(elcID, getStringID("1252"));
2183                 }
2184             } else if (key.startsWith("allfonts.")) {
2185                 key = key.substring(9);
2186                 if (key.endsWith(".motif")) {
2187                     key = key.substring(0, key.length() - 6);
2188                     //System.out.println("motif: all." + key + "=" + value);
2189                     scriptAllfontsMotif.put(getID(scriptIDs,key), getID(componentFontNameIDs,value));
2190                 } else {
2191                     scriptAllfonts.put(getID(scriptIDs,key), getID(componentFontNameIDs,value));
2192                 }
2193             } else if (key.startsWith("awtfontpath.")) {
2194                 key = key.substring(12);
2195                 //System.out.println("scriptID=" + getID(scriptIDs, key) + "/" + key);
2196                 awtfontpaths.put(getID(scriptIDs, key), getStringID(value));
2197             } else if ("version".equals(key)) {
2198                 version = value;
2199             } else if ("appendedfontpath".equals(key)) {
2200                 appendedfontpath = value;
2201             } else if (key.startsWith("proportional.")) {
2202                 key = key.substring(13).replace('_', ' ');
2203                 //System.out.println(key + "=" + value);
2204                 proportionals.put(getID(componentFontNameIDs, key),
2205                                   getID(componentFontNameIDs, value));
2206             } else {
2207                 //"name.style.script(.motif)", we don't care anything else
2208                 int dot1, dot2;
2209                 boolean isMotif = false;
2210 
2211                 dot1 = key.indexOf('.');
2212                 if (dot1 == -1) {
2213                     if (logger != null) {
2214                         logger.config("Failed parsing " + key +
2215                                   " property of font configuration.");
2216 
2217                     }
2218                     return;
2219                 }
2220                 dot2 = key.indexOf('.', dot1 + 1);
2221                 if (dot2 == -1) {
2222                     if (logger != null) {
2223                         logger.config("Failed parsing " + key +
2224                                   " property of font configuration.");
2225 
2226                     }
2227                     return;
2228                 }
2229                 if (key.endsWith(".motif")) {
2230                     key = key.substring(0, key.length() - 6);
2231                     isMotif = true;
2232                     //System.out.println("motif: " + key + "=" + value);
2233                 }
2234                 Integer nameID = logicalFontIDs.get(key.substring(0, dot1));
2235                 Integer styleID = fontStyleIDs.get(key.substring(dot1+1, dot2));
2236                 Short scriptID = getID(scriptIDs, key.substring(dot2 + 1));
2237                 if (nameID == null || styleID == null) {
2238                     if (logger != null) {
2239                         logger.config("unrecognizable logicfont name/style at " + key);
2240                     }
2241                     return;
2242                 }
2243                 Short[] pnids;
2244                 if (isMotif) {
2245                     pnids = scriptFontsMotif.get(scriptID);
2246                 } else {
2247                     pnids = scriptFonts.get(scriptID);
2248                 }
2249                 if (pnids == null) {
2250                     pnids =  new Short[20];
2251                 }
2252                 pnids[nameID.intValue() * NUM_STYLES + styleID.intValue()]
2253                   = getID(componentFontNameIDs, value);
2254                 /*
2255                 System.out.println("key=" + key + "/<" + nameID + "><" + styleID
2256                                      + "><" + scriptID + ">=" + value
2257                                      + "/" + getID(componentFontNameIDs, value));
2258                 */
2259                 if (isMotif) {
2260                     scriptFontsMotif.put(scriptID, pnids);
2261                 } else {
2262                     scriptFonts.put(scriptID, pnids);
2263                 }
2264             }
2265         }
2266     }
2267 }
--- EOF ---