| /* |
| * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.awt; |
| |
| import java.awt.Font; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.InputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.nio.charset.Charset; |
| import java.nio.charset.CharsetEncoder; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Hashtable; |
| import java.util.Locale; |
| import java.util.Map.Entry; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.Vector; |
| import sun.font.CompositeFontDescriptor; |
| import sun.font.SunFontManager; |
| import sun.font.FontManagerFactory; |
| import sun.font.FontUtilities; |
| import sun.util.logging.PlatformLogger; |
| |
| /** |
| * Provides the definitions of the five logical fonts: Serif, SansSerif, |
| * Monospaced, Dialog, and DialogInput. The necessary information |
| * is obtained from fontconfig files. |
| */ |
| public abstract class FontConfiguration { |
| |
| //static global runtime env |
| protected static String osVersion; |
| protected static String osName; |
| protected static String encoding; // canonical name of default nio charset |
| protected static Locale startupLocale = null; |
| protected static Hashtable localeMap = null; |
| private static FontConfiguration fontConfig; |
| private static PlatformLogger logger; |
| protected static boolean isProperties = true; |
| |
| protected SunFontManager fontManager; |
| protected boolean preferLocaleFonts; |
| protected boolean preferPropFonts; |
| |
| private File fontConfigFile; |
| private boolean foundOsSpecificFile; |
| private boolean inited; |
| private String javaLib; |
| |
| /* A default FontConfiguration must be created before an alternate |
| * one to ensure proper static initialisation takes place. |
| */ |
| public FontConfiguration(SunFontManager fm) { |
| if (FontUtilities.debugFonts()) { |
| FontUtilities.getLogger() |
| .info("Creating standard Font Configuration"); |
| } |
| if (FontUtilities.debugFonts() && logger == null) { |
| logger = PlatformLogger.getLogger("sun.awt.FontConfiguration"); |
| } |
| fontManager = fm; |
| setOsNameAndVersion(); /* static initialization */ |
| setEncoding(); /* static initialization */ |
| /* Separating out the file location from the rest of the |
| * initialisation, so the caller has the option of doing |
| * something else if a suitable file isn't found. |
| */ |
| findFontConfigFile(); |
| } |
| |
| public synchronized boolean init() { |
| if (!inited) { |
| this.preferLocaleFonts = false; |
| this.preferPropFonts = false; |
| setFontConfiguration(); |
| readFontConfigFile(fontConfigFile); |
| initFontConfig(); |
| inited = true; |
| } |
| return true; |
| } |
| |
| public FontConfiguration(SunFontManager fm, |
| boolean preferLocaleFonts, |
| boolean preferPropFonts) { |
| fontManager = fm; |
| if (FontUtilities.debugFonts()) { |
| FontUtilities.getLogger() |
| .info("Creating alternate Font Configuration"); |
| } |
| this.preferLocaleFonts = preferLocaleFonts; |
| this.preferPropFonts = preferPropFonts; |
| /* fontConfig should be initialised by default constructor, and |
| * its data tables can be shared, since readFontConfigFile doesn't |
| * update any other state. Also avoid a doPrivileged block. |
| */ |
| initFontConfig(); |
| } |
| |
| /** |
| * Fills in this instance's osVersion and osName members. By |
| * default uses the system properties os.name and os.version; |
| * subclasses may override. |
| */ |
| protected void setOsNameAndVersion() { |
| osName = System.getProperty("os.name"); |
| osVersion = System.getProperty("os.version"); |
| } |
| |
| private void setEncoding() { |
| encoding = Charset.defaultCharset().name(); |
| startupLocale = SunToolkit.getStartupLocale(); |
| } |
| |
| ///////////////////////////////////////////////////////////////////// |
| // methods for loading the FontConfig file // |
| ///////////////////////////////////////////////////////////////////// |
| |
| public boolean foundOsSpecificFile() { |
| return foundOsSpecificFile; |
| } |
| |
| /* Smoke test to see if we can trust this configuration by testing if |
| * the first slot of a composite font maps to an installed file. |
| */ |
| public boolean fontFilesArePresent() { |
| init(); |
| short fontNameID = compFontNameIDs[0][0][0]; |
| short fileNameID = getComponentFileID(fontNameID); |
| final String fileName = mapFileName(getComponentFileName(fileNameID)); |
| Boolean exists = (Boolean)java.security.AccessController.doPrivileged( |
| new java.security.PrivilegedAction() { |
| public Object run() { |
| try { |
| File f = new File(fileName); |
| return Boolean.valueOf(f.exists()); |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| }); |
| return exists.booleanValue(); |
| } |
| |
| private void findFontConfigFile() { |
| |
| foundOsSpecificFile = true; // default assumption. |
| String javaHome = System.getProperty("java.home"); |
| if (javaHome == null) { |
| throw new Error("java.home property not set"); |
| } |
| javaLib = javaHome + File.separator + "lib"; |
| String userConfigFile = System.getProperty("sun.awt.fontconfig"); |
| if (userConfigFile != null) { |
| fontConfigFile = new File(userConfigFile); |
| } else { |
| fontConfigFile = findFontConfigFile(javaLib); |
| } |
| } |
| |
| private void readFontConfigFile(File f) { |
| /* This is invoked here as readFontConfigFile is only invoked |
| * once per VM, and always in a privileged context, thus the |
| * directory containing installed fall back fonts is accessed |
| * from this context |
| */ |
| getInstalledFallbackFonts(javaLib); |
| |
| if (f != null) { |
| try { |
| FileInputStream in = new FileInputStream(f.getPath()); |
| if (isProperties) { |
| loadProperties(in); |
| } else { |
| loadBinary(in); |
| } |
| in.close(); |
| if (FontUtilities.debugFonts()) { |
| logger.config("Read logical font configuration from " + f); |
| } |
| } catch (IOException e) { |
| if (FontUtilities.debugFonts()) { |
| logger.config("Failed to read logical font configuration from " + f); |
| } |
| } |
| } |
| String version = getVersion(); |
| if (!"1".equals(version) && FontUtilities.debugFonts()) { |
| logger.config("Unsupported fontconfig version: " + version); |
| } |
| } |
| |
| protected void getInstalledFallbackFonts(String javaLib) { |
| String fallbackDirName = javaLib + File.separator + |
| "fonts" + File.separator + "fallback"; |
| |
| File fallbackDir = new File(fallbackDirName); |
| if (fallbackDir.exists() && fallbackDir.isDirectory()) { |
| String[] ttfs = fallbackDir.list(fontManager.getTrueTypeFilter()); |
| String[] t1s = fallbackDir.list(fontManager.getType1Filter()); |
| int numTTFs = (ttfs == null) ? 0 : ttfs.length; |
| int numT1s = (t1s == null) ? 0 : t1s.length; |
| int len = numTTFs + numT1s; |
| if (numTTFs + numT1s == 0) { |
| return; |
| } |
| installedFallbackFontFiles = new String[len]; |
| for (int i=0; i<numTTFs; i++) { |
| installedFallbackFontFiles[i] = |
| fallbackDir + File.separator + ttfs[i]; |
| } |
| for (int i=0; i<numT1s; i++) { |
| installedFallbackFontFiles[i+numTTFs] = |
| fallbackDir + File.separator + t1s[i]; |
| } |
| fontManager.registerFontsInDir(fallbackDirName); |
| } |
| } |
| |
| private File findImpl(String fname) { |
| File f = new File(fname + ".properties"); |
| if (f.canRead()) { |
| isProperties = true; |
| return f; |
| } |
| f = new File(fname + ".bfc"); |
| if (f.canRead()) { |
| isProperties = false; |
| return f; |
| } |
| return null; |
| } |
| |
| private File findFontConfigFile(String javaLib) { |
| String baseName = javaLib + File.separator + "fontconfig"; |
| File configFile; |
| String osMajorVersion = null; |
| if (osVersion != null && osName != null) { |
| configFile = findImpl(baseName + "." + osName + "." + osVersion); |
| if (configFile != null) { |
| return configFile; |
| } |
| int decimalPointIndex = osVersion.indexOf("."); |
| if (decimalPointIndex != -1) { |
| osMajorVersion = osVersion.substring(0, osVersion.indexOf(".")); |
| configFile = findImpl(baseName + "." + osName + "." + osMajorVersion); |
| if (configFile != null) { |
| return configFile; |
| } |
| } |
| } |
| if (osName != null) { |
| configFile = findImpl(baseName + "." + osName); |
| if (configFile != null) { |
| return configFile; |
| } |
| } |
| if (osVersion != null) { |
| configFile = findImpl(baseName + "." + osVersion); |
| if (configFile != null) { |
| return configFile; |
| } |
| if (osMajorVersion != null) { |
| configFile = findImpl(baseName + "." + osMajorVersion); |
| if (configFile != null) { |
| return configFile; |
| } |
| } |
| } |
| foundOsSpecificFile = false; |
| |
| configFile = findImpl(baseName); |
| if (configFile != null) { |
| return configFile; |
| } |
| return null; |
| } |
| |
| /* Initialize the internal data tables from binary format font |
| * configuration file. |
| */ |
| public static void loadBinary(InputStream inStream) throws IOException { |
| DataInputStream in = new DataInputStream(inStream); |
| head = readShortTable(in, HEAD_LENGTH); |
| int[] tableSizes = new int[INDEX_TABLEEND]; |
| for (int i = 0; i < INDEX_TABLEEND; i++) { |
| tableSizes[i] = head[i + 1] - head[i]; |
| } |
| table_scriptIDs = readShortTable(in, tableSizes[INDEX_scriptIDs]); |
| table_scriptFonts = readShortTable(in, tableSizes[INDEX_scriptFonts]); |
| table_elcIDs = readShortTable(in, tableSizes[INDEX_elcIDs]); |
| table_sequences = readShortTable(in, tableSizes[INDEX_sequences]); |
| table_fontfileNameIDs = readShortTable(in, tableSizes[INDEX_fontfileNameIDs]); |
| table_componentFontNameIDs = readShortTable(in, tableSizes[INDEX_componentFontNameIDs]); |
| table_filenames = readShortTable(in, tableSizes[INDEX_filenames]); |
| table_awtfontpaths = readShortTable(in, tableSizes[INDEX_awtfontpaths]); |
| table_exclusions = readShortTable(in, tableSizes[INDEX_exclusions]); |
| table_proportionals = readShortTable(in, tableSizes[INDEX_proportionals]); |
| table_scriptFontsMotif = readShortTable(in, tableSizes[INDEX_scriptFontsMotif]); |
| table_alphabeticSuffix = readShortTable(in, tableSizes[INDEX_alphabeticSuffix]); |
| table_stringIDs = readShortTable(in, tableSizes[INDEX_stringIDs]); |
| |
| //StringTable cache |
| stringCache = new String[table_stringIDs.length + 1]; |
| |
| int len = tableSizes[INDEX_stringTable]; |
| byte[] bb = new byte[len * 2]; |
| table_stringTable = new char[len]; |
| in.read(bb); |
| int i = 0, j = 0; |
| while (i < len) { |
| table_stringTable[i++] = (char)(bb[j++] << 8 | (bb[j++] & 0xff)); |
| } |
| if (verbose) { |
| dump(); |
| } |
| } |
| |
| /* Generate a binary format font configuration from internal data |
| * tables. |
| */ |
| public static void saveBinary(OutputStream out) throws IOException { |
| sanityCheck(); |
| |
| DataOutputStream dataOut = new DataOutputStream(out); |
| writeShortTable(dataOut, head); |
| writeShortTable(dataOut, table_scriptIDs); |
| writeShortTable(dataOut, table_scriptFonts); |
| writeShortTable(dataOut, table_elcIDs); |
| writeShortTable(dataOut, table_sequences); |
| writeShortTable(dataOut, table_fontfileNameIDs); |
| writeShortTable(dataOut, table_componentFontNameIDs); |
| writeShortTable(dataOut, table_filenames); |
| writeShortTable(dataOut, table_awtfontpaths); |
| writeShortTable(dataOut, table_exclusions); |
| writeShortTable(dataOut, table_proportionals); |
| writeShortTable(dataOut, table_scriptFontsMotif); |
| writeShortTable(dataOut, table_alphabeticSuffix); |
| writeShortTable(dataOut, table_stringIDs); |
| //stringTable |
| dataOut.writeChars(new String(table_stringTable)); |
| out.close(); |
| if (verbose) { |
| dump(); |
| } |
| } |
| |
| //private static boolean loadingProperties; |
| private static short stringIDNum; |
| private static short[] stringIDs; |
| private static StringBuilder stringTable; |
| |
| public static void loadProperties(InputStream in) throws IOException { |
| //loadingProperties = true; |
| //StringID starts from "1", "0" is reserved for "not defined" |
| stringIDNum = 1; |
| stringIDs = new short[1000]; |
| stringTable = new StringBuilder(4096); |
| |
| if (verbose && logger == null) { |
| logger = PlatformLogger.getLogger("sun.awt.FontConfiguration"); |
| } |
| new PropertiesHandler().load(in); |
| |
| //loadingProperties = false; |
| stringIDs = null; |
| stringTable = null; |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////// |
| // methods for initializing the FontConfig // |
| ///////////////////////////////////////////////////////////////////// |
| |
| /** |
| * set initLocale, initEncoding and initELC for this FontConfig object |
| * currently we just simply use the startup locale and encoding |
| */ |
| private void initFontConfig() { |
| initLocale = startupLocale; |
| initEncoding = encoding; |
| if (preferLocaleFonts && !willReorderForStartupLocale()) { |
| preferLocaleFonts = false; |
| } |
| initELC = getInitELC(); |
| initAllComponentFonts(); |
| } |
| |
| //"ELC" stands for "Encoding.Language.Country". This method returns |
| //the ID of the matched elc setting of "initLocale" in elcIDs table. |
| //If no match is found, it returns the default ID, which is |
| //"NULL.NULL.NULL" in elcIDs table. |
| private short getInitELC() { |
| if (initELC != -1) { |
| return initELC; |
| } |
| HashMap <String, Integer> elcIDs = new HashMap<String, Integer>(); |
| for (int i = 0; i < table_elcIDs.length; i++) { |
| elcIDs.put(getString(table_elcIDs[i]), i); |
| } |
| String language = initLocale.getLanguage(); |
| String country = initLocale.getCountry(); |
| String elc; |
| if (elcIDs.containsKey(elc=initEncoding + "." + language + "." + country) |
| || elcIDs.containsKey(elc=initEncoding + "." + language) |
| || elcIDs.containsKey(elc=initEncoding)) { |
| initELC = elcIDs.get(elc).shortValue(); |
| } else { |
| initELC = elcIDs.get("NULL.NULL.NULL").shortValue(); |
| } |
| int i = 0; |
| while (i < table_alphabeticSuffix.length) { |
| if (initELC == table_alphabeticSuffix[i]) { |
| alphabeticSuffix = getString(table_alphabeticSuffix[i + 1]); |
| return initELC; |
| } |
| i += 2; |
| } |
| return initELC; |
| } |
| |
| public static boolean verbose; |
| private short initELC = -1; |
| private Locale initLocale; |
| private String initEncoding; |
| private String alphabeticSuffix; |
| |
| private short[][][] compFontNameIDs = new short[NUM_FONTS][NUM_STYLES][]; |
| private int[][][] compExclusions = new int[NUM_FONTS][][]; |
| private int[] compCoreNum = new int[NUM_FONTS]; |
| |
| private Set<Short> coreFontNameIDs = new HashSet<Short>(); |
| private Set<Short> fallbackFontNameIDs = new HashSet<Short>(); |
| |
| private void initAllComponentFonts() { |
| short[] fallbackScripts = getFallbackScripts(); |
| for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) { |
| short[] coreScripts = getCoreScripts(fontIndex); |
| compCoreNum[fontIndex] = coreScripts.length; |
| /* |
| System.out.println("coreScriptID=" + table_sequences[initELC * 5 + fontIndex]); |
| for (int i = 0; i < coreScripts.length; i++) { |
| System.out.println(" " + i + " :" + getString(table_scriptIDs[coreScripts[i]])); |
| } |
| */ |
| //init exclusionRanges |
| int[][] exclusions = new int[coreScripts.length][]; |
| for (int i = 0; i < coreScripts.length; i++) { |
| exclusions[i] = getExclusionRanges(coreScripts[i]); |
| } |
| compExclusions[fontIndex] = exclusions; |
| //init componentFontNames |
| for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) { |
| int index; |
| short[] nameIDs = new short[coreScripts.length + fallbackScripts.length]; |
| //core |
| for (index = 0; index < coreScripts.length; index++) { |
| nameIDs[index] = getComponentFontID(coreScripts[index], |
| fontIndex, styleIndex); |
| if (preferLocaleFonts && localeMap != null && |
| fontManager.usingAlternateFontforJALocales()) { |
| nameIDs[index] = remapLocaleMap(fontIndex, styleIndex, |
| coreScripts[index], nameIDs[index]); |
| } |
| if (preferPropFonts) { |
| nameIDs[index] = remapProportional(fontIndex, nameIDs[index]); |
| } |
| //System.out.println("nameid=" + nameIDs[index]); |
| coreFontNameIDs.add(nameIDs[index]); |
| } |
| //fallback |
| for (int i = 0; i < fallbackScripts.length; i++) { |
| short id = getComponentFontID(fallbackScripts[i], |
| fontIndex, styleIndex); |
| if (preferLocaleFonts && localeMap != null && |
| fontManager.usingAlternateFontforJALocales()) { |
| id = remapLocaleMap(fontIndex, styleIndex, fallbackScripts[i], id); |
| } |
| if (preferPropFonts) { |
| id = remapProportional(fontIndex, id); |
| } |
| if (contains(nameIDs, id, index)) { |
| continue; |
| } |
| /* |
| System.out.println("fontIndex=" + fontIndex + ", styleIndex=" + styleIndex |
| + ", fbIndex=" + i + ",fbS=" + fallbackScripts[i] + ", id=" + id); |
| */ |
| fallbackFontNameIDs.add(id); |
| nameIDs[index++] = id; |
| } |
| if (index < nameIDs.length) { |
| short[] newNameIDs = new short[index]; |
| System.arraycopy(nameIDs, 0, newNameIDs, 0, index); |
| nameIDs = newNameIDs; |
| } |
| compFontNameIDs[fontIndex][styleIndex] = nameIDs; |
| } |
| } |
| } |
| |
| private short remapLocaleMap(int fontIndex, int styleIndex, short scriptID, short fontID) { |
| String scriptName = getString(table_scriptIDs[scriptID]); |
| |
| String value = (String)localeMap.get(scriptName); |
| if (value == null) { |
| String fontName = fontNames[fontIndex]; |
| String styleName = styleNames[styleIndex]; |
| value = (String)localeMap.get(fontName + "." + styleName + "." + scriptName); |
| } |
| if (value == null) { |
| return fontID; |
| } |
| |
| for (int i = 0; i < table_componentFontNameIDs.length; i++) { |
| String name = getString(table_componentFontNameIDs[i]); |
| if (value.equalsIgnoreCase(name)) { |
| fontID = (short)i; |
| break; |
| } |
| } |
| return fontID; |
| } |
| |
| public static boolean hasMonoToPropMap() { |
| return table_proportionals != null && table_proportionals.length != 0; |
| } |
| |
| private short remapProportional(int fontIndex, short id) { |
| if (preferPropFonts && |
| table_proportionals.length != 0 && |
| fontIndex != 2 && //"monospaced" |
| fontIndex != 4) { //"dialoginput" |
| int i = 0; |
| while (i < table_proportionals.length) { |
| if (table_proportionals[i] == id) { |
| return table_proportionals[i + 1]; |
| } |
| i += 2; |
| } |
| } |
| return id; |
| } |
| |
| ///////////////////////////////////////////////////////////////////// |
| // Methods for handling font and style names // |
| ///////////////////////////////////////////////////////////////////// |
| protected static final int NUM_FONTS = 5; |
| protected static final int NUM_STYLES = 4; |
| protected static final String[] fontNames |
| = {"serif", "sansserif", "monospaced", "dialog", "dialoginput"}; |
| protected static final String[] publicFontNames |
| = {Font.SERIF, Font.SANS_SERIF, Font.MONOSPACED, Font.DIALOG, |
| Font.DIALOG_INPUT}; |
| protected static final String[] styleNames |
| = {"plain", "bold", "italic", "bolditalic"}; |
| |
| /** |
| * Checks whether the given font family name is a valid logical font name. |
| * The check is case insensitive. |
| */ |
| public static boolean isLogicalFontFamilyName(String fontName) { |
| return isLogicalFontFamilyNameLC(fontName.toLowerCase(Locale.ENGLISH)); |
| } |
| |
| /** |
| * Checks whether the given font family name is a valid logical font name. |
| * The check is case sensitive. |
| */ |
| public static boolean isLogicalFontFamilyNameLC(String fontName) { |
| for (int i = 0; i < fontNames.length; i++) { |
| if (fontName.equals(fontNames[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Checks whether the given style name is a valid logical font style name. |
| */ |
| private static boolean isLogicalFontStyleName(String styleName) { |
| for (int i = 0; i < styleNames.length; i++) { |
| if (styleName.equals(styleNames[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Checks whether the given font face name is a valid logical font name. |
| * The check is case insensitive. |
| */ |
| public static boolean isLogicalFontFaceName(String fontName) { |
| return isLogicalFontFaceNameLC(fontName.toLowerCase(Locale.ENGLISH)); |
| } |
| |
| /** |
| * Checks whether the given font face name is a valid logical font name. |
| * The check is case sensitive. |
| */ |
| public static boolean isLogicalFontFaceNameLC(String fontName) { |
| int period = fontName.indexOf('.'); |
| if (period >= 0) { |
| String familyName = fontName.substring(0, period); |
| String styleName = fontName.substring(period + 1); |
| return isLogicalFontFamilyName(familyName) && |
| isLogicalFontStyleName(styleName); |
| } else { |
| return isLogicalFontFamilyName(fontName); |
| } |
| } |
| |
| protected static int getFontIndex(String fontName) { |
| return getArrayIndex(fontNames, fontName); |
| } |
| |
| protected static int getStyleIndex(String styleName) { |
| return getArrayIndex(styleNames, styleName); |
| } |
| |
| private static int getArrayIndex(String[] names, String name) { |
| for (int i = 0; i < names.length; i++) { |
| if (name.equals(names[i])) { |
| return i; |
| } |
| } |
| assert false; |
| return 0; |
| } |
| |
| protected static int getStyleIndex(int style) { |
| switch (style) { |
| case Font.PLAIN: |
| return 0; |
| case Font.BOLD: |
| return 1; |
| case Font.ITALIC: |
| return 2; |
| case Font.BOLD | Font.ITALIC: |
| return 3; |
| default: |
| return 0; |
| } |
| } |
| |
| protected static String getFontName(int fontIndex) { |
| return fontNames[fontIndex]; |
| } |
| |
| protected static String getStyleName(int styleIndex) { |
| return styleNames[styleIndex]; |
| } |
| |
| /** |
| * Returns the font face name for the given logical font |
| * family name and style. |
| * The style argument is interpreted as in java.awt.Font.Font. |
| */ |
| public static String getLogicalFontFaceName(String familyName, int style) { |
| assert isLogicalFontFamilyName(familyName); |
| return familyName.toLowerCase(Locale.ENGLISH) + "." + getStyleString(style); |
| } |
| |
| /** |
| * Returns the string typically used in properties files |
| * for the given style. |
| * The style argument is interpreted as in java.awt.Font.Font. |
| */ |
| public static String getStyleString(int style) { |
| return getStyleName(getStyleIndex(style)); |
| } |
| |
| /** |
| * Returns a fallback name for the given font name. For a few known |
| * font names, matching logical font names are returned. For all |
| * other font names, defaultFallback is returned. |
| * defaultFallback differs between AWT and 2D. |
| */ |
| public abstract String getFallbackFamilyName(String fontName, String defaultFallback); |
| |
| /** |
| * Returns the 1.1 equivalent for some old 1.0 font family names for |
| * which we need to maintain compatibility in some configurations. |
| * Returns null for other font names. |
| */ |
| protected String getCompatibilityFamilyName(String fontName) { |
| fontName = fontName.toLowerCase(Locale.ENGLISH); |
| if (fontName.equals("timesroman")) { |
| return "serif"; |
| } else if (fontName.equals("helvetica")) { |
| return "sansserif"; |
| } else if (fontName.equals("courier")) { |
| return "monospaced"; |
| } |
| return null; |
| } |
| |
| protected static String[] installedFallbackFontFiles = null; |
| |
| /** |
| * Maps a file name given in the font configuration file |
| * to a format appropriate for the platform. |
| */ |
| protected String mapFileName(String fileName) { |
| return fileName; |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| // reordering // |
| ////////////////////////////////////////////////////////////////////// |
| |
| /* Mappings from file encoding to font config name for font supporting |
| * the corresponding language. This is filled in by initReorderMap() |
| */ |
| protected HashMap reorderMap = null; |
| |
| /* Platform-specific mappings */ |
| protected abstract void initReorderMap(); |
| |
| /* Move item at index "src" to "dst", shuffling all values in |
| * between down |
| */ |
| private void shuffle(String[] seq, int src, int dst) { |
| if (dst >= src) { |
| return; |
| } |
| String tmp = seq[src]; |
| for (int i=src; i>dst; i--) { |
| seq[i] = seq[i-1]; |
| } |
| seq[dst] = tmp; |
| } |
| |
| /* Called to determine if there's a re-order sequence for this locale/ |
| * encoding. If there's none then the caller can "bail" and avoid |
| * unnecessary work |
| */ |
| public static boolean willReorderForStartupLocale() { |
| return getReorderSequence() != null; |
| } |
| |
| private static Object getReorderSequence() { |
| if (fontConfig.reorderMap == null) { |
| fontConfig.initReorderMap(); |
| } |
| HashMap reorderMap = fontConfig.reorderMap; |
| |
| /* Find the most specific mapping */ |
| String language = startupLocale.getLanguage(); |
| String country = startupLocale.getCountry(); |
| Object val = reorderMap.get(encoding + "." + language + "." + country); |
| if (val == null) { |
| val = reorderMap.get(encoding + "." + language); |
| } |
| if (val == null) { |
| val = reorderMap.get(encoding); |
| } |
| return val; |
| } |
| |
| /* This method reorders the sequence such that the matches for the |
| * file encoding are moved ahead of other elements. |
| * If an encoding uses more than one font, they are all moved up. |
| */ |
| private void reorderSequenceForLocale(String[] seq) { |
| Object val = getReorderSequence(); |
| if (val instanceof String) { |
| for (int i=0; i< seq.length; i++) { |
| if (seq[i].equals(val)) { |
| shuffle(seq, i, 0); |
| return; |
| } |
| } |
| } else if (val instanceof String[]) { |
| String[] fontLangs = (String[])val; |
| for (int l=0; l<fontLangs.length;l++) { |
| for (int i=0; i<seq.length;i++) { |
| if (seq[i].equals(fontLangs[l])) { |
| shuffle(seq, i, l); |
| } |
| } |
| } |
| } |
| } |
| |
| private static Vector splitSequence(String sequence) { |
| //String.split would be more convenient, but incurs big performance penalty |
| Vector parts = new Vector(); |
| int start = 0; |
| int end; |
| while ((end = sequence.indexOf(',', start)) >= 0) { |
| parts.add(sequence.substring(start, end)); |
| start = end + 1; |
| } |
| if (sequence.length() > start) { |
| parts.add(sequence.substring(start, sequence.length())); |
| } |
| return parts; |
| } |
| |
| protected String[] split(String sequence) { |
| Vector v = splitSequence(sequence); |
| return (String[])v.toArray(new String[0]); |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| // Methods for extracting information from the fontconfig data for AWT// |
| //////////////////////////////////////////////////////////////////////// |
| private Hashtable charsetRegistry = new Hashtable(5); |
| |
| /** |
| * Returns FontDescriptors describing the physical fonts used for the |
| * given logical font name and style. The font name is interpreted |
| * in a case insensitive way. |
| * The style argument is interpreted as in java.awt.Font.Font. |
| */ |
| public FontDescriptor[] getFontDescriptors(String fontName, int style) { |
| assert isLogicalFontFamilyName(fontName); |
| fontName = fontName.toLowerCase(Locale.ENGLISH); |
| int fontIndex = getFontIndex(fontName); |
| int styleIndex = getStyleIndex(style); |
| return getFontDescriptors(fontIndex, styleIndex); |
| } |
| private FontDescriptor[][][] fontDescriptors = |
| new FontDescriptor[NUM_FONTS][NUM_STYLES][]; |
| |
| private FontDescriptor[] getFontDescriptors(int fontIndex, int styleIndex) { |
| FontDescriptor[] descriptors = fontDescriptors[fontIndex][styleIndex]; |
| if (descriptors == null) { |
| descriptors = buildFontDescriptors(fontIndex, styleIndex); |
| fontDescriptors[fontIndex][styleIndex] = descriptors; |
| } |
| return descriptors; |
| } |
| |
| private FontDescriptor[] buildFontDescriptors(int fontIndex, int styleIndex) { |
| String fontName = fontNames[fontIndex]; |
| String styleName = styleNames[styleIndex]; |
| |
| short[] scriptIDs = getCoreScripts(fontIndex); |
| short[] nameIDs = compFontNameIDs[fontIndex][styleIndex]; |
| String[] sequence = new String[scriptIDs.length]; |
| String[] names = new String[scriptIDs.length]; |
| for (int i = 0; i < sequence.length; i++) { |
| names[i] = getComponentFontName(nameIDs[i]); |
| sequence[i] = getScriptName(scriptIDs[i]); |
| if (alphabeticSuffix != null && "alphabetic".equals(sequence[i])) { |
| sequence[i] = sequence[i] + "/" + alphabeticSuffix; |
| } |
| } |
| int[][] fontExclusionRanges = compExclusions[fontIndex]; |
| |
| FontDescriptor[] descriptors = new FontDescriptor[names.length]; |
| |
| for (int i = 0; i < names.length; i++) { |
| String awtFontName; |
| String encoding; |
| |
| awtFontName = makeAWTFontName(names[i], sequence[i]); |
| |
| // look up character encoding |
| encoding = getEncoding(names[i], sequence[i]); |
| if (encoding == null) { |
| encoding = "default"; |
| } |
| CharsetEncoder enc |
| = getFontCharsetEncoder(encoding.trim(), awtFontName); |
| |
| // we already have the exclusion ranges |
| int[] exclusionRanges = fontExclusionRanges[i]; |
| |
| // create descriptor |
| descriptors[i] = new FontDescriptor(awtFontName, enc, exclusionRanges); |
| } |
| return descriptors; |
| } |
| |
| /** |
| * Returns the AWT font name for the given platform font name and |
| * character subset. |
| */ |
| protected String makeAWTFontName(String platformFontName, |
| String characterSubsetName) { |
| return platformFontName; |
| } |
| |
| /** |
| * Returns the java.io name of the platform character encoding for the |
| * given AWT font name and character subset. May return "default" |
| * to indicate that getDefaultFontCharset should be called to obtain |
| * a charset encoder. |
| */ |
| protected abstract String getEncoding(String awtFontName, |
| String characterSubsetName); |
| |
| private CharsetEncoder getFontCharsetEncoder(final String charsetName, |
| String fontName) { |
| |
| Charset fc = null; |
| if (charsetName.equals("default")) { |
| fc = (Charset) charsetRegistry.get(fontName); |
| } else { |
| fc = (Charset) charsetRegistry.get(charsetName); |
| } |
| if (fc != null) { |
| return fc.newEncoder(); |
| } |
| |
| if (!charsetName.startsWith("sun.awt.") && !charsetName.equals("default")) { |
| fc = Charset.forName(charsetName); |
| } else { |
| Class fcc = (Class) AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| try { |
| return Class.forName(charsetName, true, |
| ClassLoader.getSystemClassLoader()); |
| } catch (ClassNotFoundException e) { |
| } |
| return null; |
| } |
| }); |
| |
| if (fcc != null) { |
| try { |
| fc = (Charset) fcc.newInstance(); |
| } catch (Exception e) { |
| } |
| } |
| } |
| if (fc == null) { |
| fc = getDefaultFontCharset(fontName); |
| } |
| |
| if (charsetName.equals("default")){ |
| charsetRegistry.put(fontName, fc); |
| } else { |
| charsetRegistry.put(charsetName, fc); |
| } |
| return fc.newEncoder(); |
| } |
| |
| protected abstract Charset getDefaultFontCharset( |
| String fontName); |
| |
| /* This retrieves the platform font directories (path) calculated |
| * by setAWTFontPathSequence(String[]). The default implementation |
| * returns null, its expected that X11 platforms may return |
| * non-null. |
| */ |
| public HashSet<String> getAWTFontPathSet() { |
| return null; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| // methods for extracting information from the fontconfig data for 2D // |
| //////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Returns an array of composite font descriptors for all logical font |
| * faces. |
| * If the font configuration file doesn't specify Lucida Sans Regular |
| * or the given fallback font as component fonts, they are added here. |
| */ |
| public CompositeFontDescriptor[] get2DCompositeFontInfo() { |
| CompositeFontDescriptor[] result = |
| new CompositeFontDescriptor[NUM_FONTS * NUM_STYLES]; |
| String defaultFontFile = fontManager.getDefaultFontFile(); |
| String defaultFontFaceName = fontManager.getDefaultFontFaceName(); |
| |
| for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) { |
| String fontName = publicFontNames[fontIndex]; |
| |
| // determine exclusion ranges for font |
| // AWT uses separate exclusion range array per component font. |
| // 2D packs all range boundaries into one array. |
| // Both use separate entries for lower and upper boundary. |
| int[][] exclusions = compExclusions[fontIndex]; |
| int numExclusionRanges = 0; |
| for (int i = 0; i < exclusions.length; i++) { |
| numExclusionRanges += exclusions[i].length; |
| } |
| int[] exclusionRanges = new int[numExclusionRanges]; |
| int[] exclusionRangeLimits = new int[exclusions.length]; |
| int exclusionRangeIndex = 0; |
| int exclusionRangeLimitIndex = 0; |
| for (int i = 0; i < exclusions.length; i++) { |
| int[] componentRanges = exclusions[i]; |
| for (int j = 0; j < componentRanges.length; ) { |
| int value = componentRanges[j]; |
| exclusionRanges[exclusionRangeIndex++] = componentRanges[j++]; |
| exclusionRanges[exclusionRangeIndex++] = componentRanges[j++]; |
| } |
| exclusionRangeLimits[i] = exclusionRangeIndex; |
| } |
| // other info is per style |
| for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) { |
| int maxComponentFontCount = compFontNameIDs[fontIndex][styleIndex].length; |
| boolean sawDefaultFontFile = false; |
| // fall back fonts listed in the lib/fonts/fallback directory |
| if (installedFallbackFontFiles != null) { |
| maxComponentFontCount += installedFallbackFontFiles.length; |
| } |
| String faceName = fontName + "." + styleNames[styleIndex]; |
| |
| // determine face names and file names of component fonts |
| String[] componentFaceNames = new String[maxComponentFontCount]; |
| String[] componentFileNames = new String[maxComponentFontCount]; |
| |
| int index; |
| for (index = 0; index < compFontNameIDs[fontIndex][styleIndex].length; index++) { |
| short fontNameID = compFontNameIDs[fontIndex][styleIndex][index]; |
| short fileNameID = getComponentFileID(fontNameID); |
| componentFaceNames[index] = getFaceNameFromComponentFontName(getComponentFontName(fontNameID)); |
| componentFileNames[index] = mapFileName(getComponentFileName(fileNameID)); |
| if (componentFileNames[index] == null || |
| needToSearchForFile(componentFileNames[index])) { |
| componentFileNames[index] = getFileNameFromComponentFontName(getComponentFontName(fontNameID)); |
| } |
| if (!sawDefaultFontFile && |
| defaultFontFile.equals(componentFileNames[index])) { |
| sawDefaultFontFile = true; |
| } |
| /* |
| System.out.println(publicFontNames[fontIndex] + "." + styleNames[styleIndex] + "." |
| + getString(table_scriptIDs[coreScripts[index]]) + "=" + componentFileNames[index]); |
| */ |
| } |
| |
| //"Lucida Sans Regular" is not in the list, we add it here |
| if (!sawDefaultFontFile) { |
| int len = 0; |
| if (installedFallbackFontFiles != null) { |
| len = installedFallbackFontFiles.length; |
| } |
| if (index + len == maxComponentFontCount) { |
| String[] newComponentFaceNames = new String[maxComponentFontCount + 1]; |
| System.arraycopy(componentFaceNames, 0, newComponentFaceNames, 0, index); |
| componentFaceNames = newComponentFaceNames; |
| String[] newComponentFileNames = new String[maxComponentFontCount + 1]; |
| System.arraycopy(componentFileNames, 0, newComponentFileNames, 0, index); |
| componentFileNames = newComponentFileNames; |
| } |
| componentFaceNames[index] = defaultFontFaceName; |
| componentFileNames[index] = defaultFontFile; |
| index++; |
| } |
| |
| if (installedFallbackFontFiles != null) { |
| for (int ifb=0; ifb<installedFallbackFontFiles.length; ifb++) { |
| componentFaceNames[index] = null; |
| componentFileNames[index] = installedFallbackFontFiles[ifb]; |
| index++; |
| } |
| } |
| |
| if (index < maxComponentFontCount) { |
| String[] newComponentFaceNames = new String[index]; |
| System.arraycopy(componentFaceNames, 0, newComponentFaceNames, 0, index); |
| componentFaceNames = newComponentFaceNames; |
| String[] newComponentFileNames = new String[index]; |
| System.arraycopy(componentFileNames, 0, newComponentFileNames, 0, index); |
| componentFileNames = newComponentFileNames; |
| } |
| // exclusion range limit array length must match component face name |
| // array length - native code relies on this |
| |
| int[] clippedExclusionRangeLimits = exclusionRangeLimits; |
| if (index != clippedExclusionRangeLimits.length) { |
| int len = exclusionRangeLimits.length; |
| clippedExclusionRangeLimits = new int[index]; |
| System.arraycopy(exclusionRangeLimits, 0, clippedExclusionRangeLimits, 0, len); |
| //padding for various fallback fonts |
| for (int i = len; i < index; i++) { |
| clippedExclusionRangeLimits[i] = exclusionRanges.length; |
| } |
| } |
| /* |
| System.out.println(faceName + ":"); |
| for (int i = 0; i < componentFileNames.length; i++) { |
| System.out.println(" " + componentFaceNames[i] |
| + " -> " + componentFileNames[i]); |
| } |
| */ |
| result[fontIndex * NUM_STYLES + styleIndex] |
| = new CompositeFontDescriptor( |
| faceName, |
| compCoreNum[fontIndex], |
| componentFaceNames, |
| componentFileNames, |
| exclusionRanges, |
| clippedExclusionRangeLimits); |
| } |
| } |
| return result; |
| } |
| |
| protected abstract String getFaceNameFromComponentFontName(String componentFontName); |
| protected abstract String getFileNameFromComponentFontName(String componentFontName); |
| |
| /* |
| public class 2dFont { |
| public String platformName; |
| public String fontfileName; |
| } |
| private 2dFont [] componentFonts = null; |
| */ |
| |
| /* Used on Linux to test if a file referenced in a font configuration |
| * file exists in the location that is expected. If it does, no need |
| * to search for it. If it doesn't then unless its a fallback font, |
| * return that expensive code should be invoked to search for the font. |
| */ |
| HashMap<String, Boolean> existsMap; |
| public boolean needToSearchForFile(String fileName) { |
| if (!FontUtilities.isLinux) { |
| return false; |
| } else if (existsMap == null) { |
| existsMap = new HashMap<String, Boolean>(); |
| } |
| Boolean exists = existsMap.get(fileName); |
| if (exists == null) { |
| /* call getNumberCoreFonts() to ensure these are initialised, and |
| * if this file isn't for a core component, ie, is a for a fallback |
| * font which very typically isn't available, then can't afford |
| * to take the start-up penalty to search for it. |
| */ |
| getNumberCoreFonts(); |
| if (!coreFontFileNames.contains(fileName)) { |
| exists = Boolean.TRUE; |
| } else { |
| exists = Boolean.valueOf((new File(fileName)).exists()); |
| existsMap.put(fileName, exists); |
| if (FontUtilities.debugFonts() && |
| exists == Boolean.FALSE) { |
| logger.warning("Couldn't locate font file " + fileName); |
| } |
| } |
| } |
| return exists == Boolean.FALSE; |
| } |
| |
| private int numCoreFonts = -1; |
| private String[] componentFonts = null; |
| HashMap <String, String> filenamesMap = new HashMap<String, String>(); |
| HashSet <String> coreFontFileNames = new HashSet<String>(); |
| |
| /* Return the number of core fonts. Note this isn't thread safe but |
| * a calling thread can call this and getPlatformFontNames() in either |
| * order. |
| */ |
| public int getNumberCoreFonts() { |
| if (numCoreFonts == -1) { |
| numCoreFonts = coreFontNameIDs.size(); |
| Short[] emptyShortArray = new Short[0]; |
| Short[] core = coreFontNameIDs.toArray(emptyShortArray); |
| Short[] fallback = fallbackFontNameIDs.toArray(emptyShortArray); |
| |
| int numFallbackFonts = 0; |
| int i; |
| for (i = 0; i < fallback.length; i++) { |
| if (coreFontNameIDs.contains(fallback[i])) { |
| fallback[i] = null; |
| continue; |
| } |
| numFallbackFonts++; |
| } |
| componentFonts = new String[numCoreFonts + numFallbackFonts]; |
| String filename = null; |
| for (i = 0; i < core.length; i++) { |
| short fontid = core[i]; |
| short fileid = getComponentFileID(fontid); |
| componentFonts[i] = getComponentFontName(fontid); |
| String compFileName = getComponentFileName(fileid); |
| if (compFileName != null) { |
| coreFontFileNames.add(compFileName); |
| } |
| filenamesMap.put(componentFonts[i], mapFileName(compFileName)); |
| } |
| for (int j = 0; j < fallback.length; j++) { |
| if (fallback[j] != null) { |
| short fontid = fallback[j]; |
| short fileid = getComponentFileID(fontid); |
| componentFonts[i] = getComponentFontName(fontid); |
| filenamesMap.put(componentFonts[i], |
| mapFileName(getComponentFileName(fileid))); |
| i++; |
| } |
| } |
| } |
| return numCoreFonts; |
| } |
| |
| /* Return all platform font names used by this font configuration. |
| * The first getNumberCoreFonts() entries are guaranteed to be the |
| * core fonts - ie no fall back only fonts. |
| */ |
| public String[] getPlatformFontNames() { |
| if (numCoreFonts == -1) { |
| getNumberCoreFonts(); |
| } |
| return componentFonts; |
| } |
| |
| /** |
| * Returns a file name for the physical font represented by this platform font name, |
| * if the font configuration has such information available, or null if the |
| * information is unavailable. The file name returned is just a hint; a null return |
| * value doesn't necessarily mean that the font is unavailable, nor does a non-null |
| * return value guarantee that the file exists and contains the physical font. |
| * The file name can be an absolute or a relative path name. |
| */ |
| public String getFileNameFromPlatformName(String platformName) { |
| // get2DCompositeFontInfo |
| // -> getFileNameFromComponentfontName() (W/M) |
| // -> getFileNameFromPlatformName() |
| // it's a waste of time on Win32, but I have to give X11 a chance to |
| // call getFileNameFromXLFD() |
| return filenamesMap.get(platformName); |
| } |
| |
| /** |
| * Returns a configuration specific path to be appended to the font |
| * search path. |
| */ |
| public String getExtraFontPath() { |
| return getString(head[INDEX_appendedfontpath]); |
| } |
| |
| public String getVersion() { |
| return getString(head[INDEX_version]); |
| } |
| |
| /* subclass support */ |
| protected static FontConfiguration getFontConfiguration() { |
| return fontConfig; |
| } |
| |
| protected void setFontConfiguration() { |
| fontConfig = this; /* static initialization */ |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| // FontConfig data tables and the index constants in binary file // |
| ////////////////////////////////////////////////////////////////////// |
| /* The binary font configuration file begins with a short[] "head", which |
| * contains the offsets to the starts of the individual data table which |
| * immediately follow. Teh current implemention includes the tables shown |
| * below. |
| * |
| * (00) table_scriptIDs :stringIDs of all defined CharacterSubsetNames |
| * (01) table_scriptFonts :scriptID x fontIndex x styleIndex-> |
| * PlatformFontNameID mapping. Each scriptID might |
| * have 1 or 20 entries depends on if it is defined |
| * via a "allfonts.CharacterSubsetname" or a list of |
| * "LogicalFontName.StyleName.CharacterSubsetName" |
| * entries, positive entry means it's a "allfonts" |
| * entry, a negative value means this is a offset to |
| * a NUM_FONTS x NUM_STYLES subtable. |
| * (02) table_elcIDs :stringIDs of all defined ELC names, string |
| * "NULL.NULL.NULL" is used for "default" |
| * (03) table_sequences :elcID x logicalFont -> scriptIDs table defined |
| * by "sequence.allfonts/LogicalFontName.ELC" in |
| * font configuration file, each "elcID" has |
| * NUM_FONTS (5) entries in this table. |
| * (04) table_fontfileNameIDs |
| * :stringIDs of all defined font file names |
| * (05) table_componentFontNameIDs |
| * :stringIDs of all defined PlatformFontNames |
| * (06) table_filenames :platformFontNamesID->fontfileNameID mapping |
| * table, the index is the platformFontNamesID. |
| * (07) table_awtfontpaths :CharacterSubsetNames->awtfontpaths mapping table, |
| * the index is the CharacterSubsetName's stringID |
| * and content is the stringID of awtfontpath. |
| * (08) table_exclusions :scriptID -> exclusionRanges mapping table, |
| * the index is the scriptID and the content is |
| a id of an exclusionRanges int[]. |
| * (09) table_proportionals:list of pairs of PlatformFontNameIDs, stores |
| * the replacement info defined by "proportional" |
| * keyword. |
| * (10) table_scriptFontsMotif |
| * :same as (01) except this table stores the |
| * info defined with ".motif" keyword |
| * (11) table_alphabeticSuffix |
| * :elcID -> stringID of alphabetic/XXXX entries |
| * (12) table_stringIDs :The index of this table is the string ID, the |
| * content is the "start index" of this string in |
| * stringTable, use the start index of next entry |
| * as the "end index". |
| * (13) table_stringTable :The real storage of all character strings defined |
| * /used this font configuration, need a pair of |
| * "start" and "end" indices to access. |
| * (14) reserved |
| * (15) table_fallbackScripts |
| * :stringIDs of fallback CharacterSubsetnames, stored |
| * in the order of they are defined in sequence.fallback. |
| * (16) table_appendedfontpath |
| * :stringtID of the "appendedfontpath" defined. |
| * (17) table_version :stringID of the version number of this fontconfig file. |
| */ |
| private static final int HEAD_LENGTH = 20; |
| private static final int INDEX_scriptIDs = 0; |
| private static final int INDEX_scriptFonts = 1; |
| private static final int INDEX_elcIDs = 2; |
| private static final int INDEX_sequences = 3; |
| private static final int INDEX_fontfileNameIDs = 4; |
| private static final int INDEX_componentFontNameIDs = 5; |
| private static final int INDEX_filenames = 6; |
| private static final int INDEX_awtfontpaths = 7; |
| private static final int INDEX_exclusions = 8; |
| private static final int INDEX_proportionals = 9; |
| private static final int INDEX_scriptFontsMotif = 10; |
| private static final int INDEX_alphabeticSuffix = 11; |
| private static final int INDEX_stringIDs = 12; |
| private static final int INDEX_stringTable = 13; |
| private static final int INDEX_TABLEEND = 14; |
| private static final int INDEX_fallbackScripts = 15; |
| private static final int INDEX_appendedfontpath = 16; |
| private static final int INDEX_version = 17; |
| |
| private static short[] head; |
| private static short[] table_scriptIDs; |
| private static short[] table_scriptFonts; |
| private static short[] table_elcIDs; |
| private static short[] table_sequences; |
| private static short[] table_fontfileNameIDs; |
| private static short[] table_componentFontNameIDs; |
| private static short[] table_filenames; |
| protected static short[] table_awtfontpaths; |
| private static short[] table_exclusions; |
| private static short[] table_proportionals; |
| private static short[] table_scriptFontsMotif; |
| private static short[] table_alphabeticSuffix; |
| private static short[] table_stringIDs; |
| private static char[] table_stringTable; |
| |
| /** |
| * Checks consistencies of complied fontconfig data. This method |
| * is called only at the build-time from |
| * build.tools.compilefontconfig.CompileFontConfig. |
| */ |
| private static void sanityCheck() { |
| int errors = 0; |
| |
| //This method will only be called during build time, do we |
| //need do PrivilegedAction? |
| String osName = (String)java.security.AccessController.doPrivileged( |
| new java.security.PrivilegedAction() { |
| public Object run() { |
| return System.getProperty("os.name"); |
| } |
| }); |
| |
| //componentFontNameID starts from "1" |
| for (int ii = 1; ii < table_filenames.length; ii++) { |
| if (table_filenames[ii] == -1) { |
| // The corresponding finename entry for a component |
| // font name is mandatory on Windows, but it's |
| // optional on Solaris and Linux. |
| if (osName.contains("Windows")) { |
| System.err.println("\n Error: <filename." |
| + getString(table_componentFontNameIDs[ii]) |
| + "> entry is missing!!!"); |
| errors++; |
| } else { |
| if (verbose && !isEmpty(table_filenames)) { |
| System.err.println("\n Note: 'filename' entry is undefined for \"" |
| + getString(table_componentFontNameIDs[ii]) |
| + "\""); |
| } |
| } |
| } |
| } |
| for (int ii = 0; ii < table_scriptIDs.length; ii++) { |
| short fid = table_scriptFonts[ii]; |
| if (fid == 0) { |
| System.out.println("\n Error: <allfonts." |
| + getString(table_scriptIDs[ii]) |
| + "> entry is missing!!!"); |
| errors++; |
| continue; |
| } else if (fid < 0) { |
| fid = (short)-fid; |
| for (int iii = 0; iii < NUM_FONTS; iii++) { |
| for (int iij = 0; iij < NUM_STYLES; iij++) { |
| int jj = iii * NUM_STYLES + iij; |
| short ffid = table_scriptFonts[fid + jj]; |
| if (ffid == 0) { |
| System.err.println("\n Error: <" |
| + getFontName(iii) + "." |
| + getStyleName(iij) + "." |
| + getString(table_scriptIDs[ii]) |
| + "> entry is missing!!!"); |
| errors++; |
| } |
| } |
| } |
| } |
| } |
| if ("SunOS".equals(osName)) { |
| for (int ii = 0; ii < table_awtfontpaths.length; ii++) { |
| if (table_awtfontpaths[ii] == 0) { |
| String script = getString(table_scriptIDs[ii]); |
| if (script.contains("lucida") || |
| script.contains("dingbats") || |
| script.contains("symbol")) { |
| continue; |
| } |
| System.err.println("\nError: " |
| + "<awtfontpath." |
| + script |
| + "> entry is missing!!!"); |
| errors++; |
| } |
| } |
| } |
| if (errors != 0) { |
| System.err.println("!!THERE ARE " + errors + " ERROR(S) IN " |
| + "THE FONTCONFIG FILE, PLEASE CHECK ITS CONTENT!!\n"); |
| System.exit(1); |
| } |
| } |
| |
| private static boolean isEmpty(short[] a) { |
| for (short s : a) { |
| if (s != -1) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| //dump the fontconfig data tables |
| private static void dump() { |
| System.out.println("\n----Head Table------------"); |
| for (int ii = 0; ii < HEAD_LENGTH; ii++) { |
| System.out.println(" " + ii + " : " + head[ii]); |
| } |
| System.out.println("\n----scriptIDs-------------"); |
| printTable(table_scriptIDs, 0); |
| System.out.println("\n----scriptFonts----------------"); |
| for (int ii = 0; ii < table_scriptIDs.length; ii++) { |
| short fid = table_scriptFonts[ii]; |
| if (fid >= 0) { |
| System.out.println(" allfonts." |
| + getString(table_scriptIDs[ii]) |
| + "=" |
| + getString(table_componentFontNameIDs[fid])); |
| } |
| } |
| for (int ii = 0; ii < table_scriptIDs.length; ii++) { |
| short fid = table_scriptFonts[ii]; |
| if (fid < 0) { |
| fid = (short)-fid; |
| for (int iii = 0; iii < NUM_FONTS; iii++) { |
| for (int iij = 0; iij < NUM_STYLES; iij++) { |
| int jj = iii * NUM_STYLES + iij; |
| short ffid = table_scriptFonts[fid + jj]; |
| System.out.println(" " |
| + getFontName(iii) + "." |
| + getStyleName(iij) + "." |
| + getString(table_scriptIDs[ii]) |
| + "=" |
| + getString(table_componentFontNameIDs[ffid])); |
| } |
| } |
| |
| } |
| } |
| System.out.println("\n----elcIDs----------------"); |
| printTable(table_elcIDs, 0); |
| System.out.println("\n----sequences-------------"); |
| for (int ii = 0; ii< table_elcIDs.length; ii++) { |
| System.out.println(" " + ii + "/" + getString((short)table_elcIDs[ii])); |
| short[] ss = getShortArray(table_sequences[ii * NUM_FONTS + 0]); |
| for (int jj = 0; jj < ss.length; jj++) { |
| System.out.println(" " + getString((short)table_scriptIDs[ss[jj]])); |
| } |
| } |
| System.out.println("\n----fontfileNameIDs-------"); |
| printTable(table_fontfileNameIDs, 0); |
| |
| System.out.println("\n----componentFontNameIDs--"); |
| printTable(table_componentFontNameIDs, 1); |
| System.out.println("\n----filenames-------------"); |
| for (int ii = 0; ii < table_filenames.length; ii++) { |
| if (table_filenames[ii] == -1) { |
| System.out.println(" " + ii + " : null"); |
| } else { |
| System.out.println(" " + ii + " : " |
| + getString(table_fontfileNameIDs[table_filenames[ii]])); |
| } |
| } |
| System.out.println("\n----awtfontpaths---------"); |
| for (int ii = 0; ii < table_awtfontpaths.length; ii++) { |
| System.out.println(" " + getString(table_scriptIDs[ii]) |
| + " : " |
| + getString(table_awtfontpaths[ii])); |
| } |
| System.out.println("\n----proportionals--------"); |
| for (int ii = 0; ii < table_proportionals.length; ii++) { |
| System.out.println(" " |
| + getString((short)table_componentFontNameIDs[table_proportionals[ii++]]) |
| + " -> " |
| + getString((short)table_componentFontNameIDs[table_proportionals[ii]])); |
| } |
| int i = 0; |
| System.out.println("\n----alphabeticSuffix----"); |
| while (i < table_alphabeticSuffix.length) { |
| System.out.println(" " + getString(table_elcIDs[table_alphabeticSuffix[i++]]) |
| + " -> " + getString(table_alphabeticSuffix[i++])); |
| } |
| System.out.println("\n----String Table---------"); |
| System.out.println(" stringID: Num =" + table_stringIDs.length); |
| System.out.println(" stringTable: Size=" + table_stringTable.length * 2); |
| |
| System.out.println("\n----fallbackScriptIDs---"); |
| short[] fbsIDs = getShortArray(head[INDEX_fallbackScripts]); |
| for (int ii = 0; ii < fbsIDs.length; ii++) { |
| System.out.println(" " + getString(table_scriptIDs[fbsIDs[ii]])); |
| } |
| System.out.println("\n----appendedfontpath-----"); |
| System.out.println(" " + getString(head[INDEX_appendedfontpath])); |
| System.out.println("\n----Version--------------"); |
| System.out.println(" " + getString(head[INDEX_version])); |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Data table access methods // |
| ////////////////////////////////////////////////////////////////////// |
| |
| /* Return the fontID of the platformFontName defined in this font config |
| * by "LogicalFontName.StyleName.CharacterSubsetName" entry or |
| * "allfonts.CharacterSubsetName" entry in properties format fc file. |
| */ |
| protected static short getComponentFontID(short scriptID, int fontIndex, int styleIndex) { |
| short fid = table_scriptFonts[scriptID]; |
| //System.out.println("fid=" + fid + "/ scriptID=" + scriptID + ", fi=" + fontIndex + ", si=" + styleIndex); |
| if (fid >= 0) { |
| //"allfonts" |
| return fid; |
| } else { |
| return table_scriptFonts[-fid + fontIndex * NUM_STYLES + styleIndex]; |
| } |
| } |
| |
| /* Same as getCompoentFontID() except this method returns the fontID define by |
| * "xxxx.motif" entry. |
| */ |
| protected static short getComponentFontIDMotif(short scriptID, int fontIndex, int styleIndex) { |
| if (table_scriptFontsMotif.length == 0) { |
| return 0; |
| } |
| short fid = table_scriptFontsMotif[scriptID]; |
| if (fid >= 0) { |
| //"allfonts" > 0 or "not defined" == 0 |
| return fid; |
| } else { |
| return table_scriptFontsMotif[-fid + fontIndex * NUM_STYLES + styleIndex]; |
| } |
| } |
| |
| private static int[] getExclusionRanges(short scriptID) { |
| short exID = table_exclusions[scriptID]; |
| if (exID == 0) { |
| return EMPTY_INT_ARRAY; |
| } else { |
| char[] exChar = getString(exID).toCharArray(); |
| int[] exInt = new int[exChar.length / 2]; |
| int i = 0; |
| for (int j = 0; j < exInt.length; j++) { |
| exInt[j] = (exChar[i++] << 16) + (exChar[i++] & 0xffff); |
| } |
| return exInt; |
| } |
| } |
| |
| private static boolean contains(short IDs[], short id, int limit) { |
| for (int i = 0; i < limit; i++) { |
| if (IDs[i] == id) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /* Return the PlatformFontName from its fontID*/ |
| protected static String getComponentFontName(short id) { |
| if (id < 0) { |
| return null; |
| } |
| return getString(table_componentFontNameIDs[id]); |
| } |
| |
| private static String getComponentFileName(short id) { |
| if (id < 0) { |
| return null; |
| } |
| return getString(table_fontfileNameIDs[id]); |
| } |
| |
| //componentFontID -> componentFileID |
| private static short getComponentFileID(short nameID) { |
| return table_filenames[nameID]; |
| } |
| |
| private static String getScriptName(short scriptID) { |
| return getString(table_scriptIDs[scriptID]); |
| } |
| |
| private HashMap<String, Short> reorderScripts; |
| protected short[] getCoreScripts(int fontIndex) { |
| short elc = getInitELC(); |
| /* |
| System.out.println("getCoreScripts: elc=" + elc + ", fontIndex=" + fontIndex); |
| short[] ss = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]); |
| for (int i = 0; i < ss.length; i++) { |
| System.out.println(" " + getString((short)table_scriptIDs[ss[i]])); |
| } |
| */ |
| short[] scripts = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]); |
| if (preferLocaleFonts) { |
| if (reorderScripts == null) { |
| reorderScripts = new HashMap<String, Short>(); |
| } |
| String[] ss = new String[scripts.length]; |
| for (int i = 0; i < ss.length; i++) { |
| ss[i] = getScriptName(scripts[i]); |
| reorderScripts.put(ss[i], scripts[i]); |
| } |
| reorderSequenceForLocale(ss); |
| for (int i = 0; i < ss.length; i++) { |
| scripts[i] = reorderScripts.get(ss[i]); |
| } |
| } |
| return scripts; |
| } |
| |
| private static short[] getFallbackScripts() { |
| return getShortArray(head[INDEX_fallbackScripts]); |
| } |
| |
| private static void printTable(short[] list, int start) { |
| for (int i = start; i < list.length; i++) { |
| System.out.println(" " + i + " : " + getString(list[i])); |
| } |
| } |
| |
| private static short[] readShortTable(DataInputStream in, int len ) |
| throws IOException { |
| if (len == 0) { |
| return EMPTY_SHORT_ARRAY; |
| } |
| short[] data = new short[len]; |
| byte[] bb = new byte[len * 2]; |
| in.read(bb); |
| int i = 0,j = 0; |
| while (i < len) { |
| data[i++] = (short)(bb[j++] << 8 | (bb[j++] & 0xff)); |
| } |
| return data; |
| } |
| |
| private static void writeShortTable(DataOutputStream out, short[] data) |
| throws IOException { |
| for (short val : data) { |
| out.writeShort(val); |
| } |
| } |
| |
| private static short[] toList(HashMap<String, Short> map) { |
| short[] list = new short[map.size()]; |
| Arrays.fill(list, (short) -1); |
| for (Entry<String, Short> entry : map.entrySet()) { |
| list[entry.getValue()] = getStringID(entry.getKey()); |
| } |
| return list; |
| } |
| |
| //runtime cache |
| private static String[] stringCache; |
| protected static String getString(short stringID) { |
| if (stringID == 0) |
| return null; |
| /* |
| if (loadingProperties) { |
| return stringTable.substring(stringIDs[stringID], |
| stringIDs[stringID+1]); |
| } |
| */ |
| //sync if we want it to be MT-enabled |
| if (stringCache[stringID] == null){ |
| stringCache[stringID] = |
| new String (table_stringTable, |
| table_stringIDs[stringID], |
| table_stringIDs[stringID+1] - table_stringIDs[stringID]); |
| } |
| return stringCache[stringID]; |
| } |
| |
| private static short[] getShortArray(short shortArrayID) { |
| String s = getString(shortArrayID); |
| char[] cc = s.toCharArray(); |
| short[] ss = new short[cc.length]; |
| for (int i = 0; i < cc.length; i++) { |
| ss[i] = (short)(cc[i] & 0xffff); |
| } |
| return ss; |
| } |
| |
| private static short getStringID(String s) { |
| if (s == null) { |
| return (short)0; |
| } |
| short pos0 = (short)stringTable.length(); |
| stringTable.append(s); |
| short pos1 = (short)stringTable.length(); |
| |
| stringIDs[stringIDNum] = pos0; |
| stringIDs[stringIDNum + 1] = pos1; |
| stringIDNum++; |
| if (stringIDNum + 1 >= stringIDs.length) { |
| short[] tmp = new short[stringIDNum + 1000]; |
| System.arraycopy(stringIDs, 0, tmp, 0, stringIDNum); |
| stringIDs = tmp; |
| } |
| return (short)(stringIDNum - 1); |
| } |
| |
| private static short getShortArrayID(short sa[]) { |
| char[] cc = new char[sa.length]; |
| for (int i = 0; i < sa.length; i ++) { |
| cc[i] = (char)sa[i]; |
| } |
| String s = new String(cc); |
| return getStringID(s); |
| } |
| |
| //utility "empty" objects |
| private static final int[] EMPTY_INT_ARRAY = new int[0]; |
| private static final String[] EMPTY_STRING_ARRAY = new String[0]; |
| private static final short[] EMPTY_SHORT_ARRAY = new short[0]; |
| private static final String UNDEFINED_COMPONENT_FONT = "unknown"; |
| |
| ////////////////////////////////////////////////////////////////////////// |
| //Convert the FontConfig data in Properties file to binary data tables // |
| ////////////////////////////////////////////////////////////////////////// |
| static class PropertiesHandler { |
| public void load(InputStream in) throws IOException { |
| initLogicalNameStyle(); |
| initHashMaps(); |
| FontProperties fp = new FontProperties(); |
| fp.load(in); |
| initBinaryTable(); |
| } |
| |
| private void initBinaryTable() { |
| //(0) |
| head = new short[HEAD_LENGTH]; |
| head[INDEX_scriptIDs] = (short)HEAD_LENGTH; |
| |
| table_scriptIDs = toList(scriptIDs); |
| //(1)a: scriptAllfonts scriptID/allfonts -> componentFontNameID |
| // b: scriptFonts scriptID -> componentFontNameID[20] |
| //if we have a "allfonts.script" def, then we just put |
| //the "-platformFontID" value in the slot, otherwise the slot |
| //value is "offset" which "offset" is where 20 entries located |
| //in the table attached. |
| head[INDEX_scriptFonts] = (short)(head[INDEX_scriptIDs] + table_scriptIDs.length); |
| int len = table_scriptIDs.length + scriptFonts.size() * 20; |
| table_scriptFonts = new short[len]; |
| |
| for (Entry<Short, Short> entry : scriptAllfonts.entrySet()) { |
| table_scriptFonts[entry.getKey().intValue()] = entry.getValue(); |
| } |
| int off = table_scriptIDs.length; |
| for (Entry<Short, Short[]> entry : scriptFonts.entrySet()) { |
| table_scriptFonts[entry.getKey().intValue()] = (short)-off; |
| Short[] v = entry.getValue(); |
| for (int i = 0; i < 20; i++) { |
| if (v[i] != null) { |
| table_scriptFonts[off++] = v[i]; |
| } else { |
| table_scriptFonts[off++] = 0; |
| } |
| } |
| } |
| |
| //(2) |
| head[INDEX_elcIDs] = (short)(head[INDEX_scriptFonts] + table_scriptFonts.length); |
| table_elcIDs = toList(elcIDs); |
| |
| //(3) sequences elcID -> XXXX[1|5] -> scriptID[] |
| head[INDEX_sequences] = (short)(head[INDEX_elcIDs] + table_elcIDs.length); |
| table_sequences = new short[elcIDs.size() * NUM_FONTS]; |
| for (Entry<Short, short[]> entry : sequences.entrySet()) { |
| //table_sequences[entry.getKey().intValue()] = (short)-off; |
| int k = entry.getKey().intValue(); |
| short[] v = entry.getValue(); |
| /* |
| System.out.println("elc=" + k + "/" + getString((short)table_elcIDs[k])); |
| short[] ss = getShortArray(v[0]); |
| for (int i = 0; i < ss.length; i++) { |
| System.out.println(" " + getString((short)table_scriptIDs[ss[i]])); |
| } |
| */ |
| if (v.length == 1) { |
| //the "allfonts" entries |
| for (int i = 0; i < NUM_FONTS; i++) { |
| table_sequences[k * NUM_FONTS + i] = v[0]; |
| } |
| } else { |
| for (int i = 0; i < NUM_FONTS; i++) { |
| table_sequences[k * NUM_FONTS + i] = v[i]; |
| } |
| } |
| } |
| //(4) |
| head[INDEX_fontfileNameIDs] = (short)(head[INDEX_sequences] + table_sequences.length); |
| table_fontfileNameIDs = toList(fontfileNameIDs); |
| |
| //(5) |
| head[INDEX_componentFontNameIDs] = (short)(head[INDEX_fontfileNameIDs] + table_fontfileNameIDs.length); |
| table_componentFontNameIDs = toList(componentFontNameIDs); |
| |
| //(6)componentFontNameID -> filenameID |
| head[INDEX_filenames] = (short)(head[INDEX_componentFontNameIDs] + table_componentFontNameIDs.length); |
| table_filenames = new short[table_componentFontNameIDs.length]; |
| Arrays.fill(table_filenames, (short) -1); |
| |
| for (Entry<Short, Short> entry : filenames.entrySet()) { |
| table_filenames[entry.getKey()] = entry.getValue(); |
| } |
| |
| //(7)scriptID-> awtfontpath |
| //the paths are stored as scriptID -> stringID in awtfontpahts |
| head[INDEX_awtfontpaths] = (short)(head[INDEX_filenames] + table_filenames.length); |
| table_awtfontpaths = new short[table_scriptIDs.length]; |
| for (Entry<Short, Short> entry : awtfontpaths.entrySet()) { |
| table_awtfontpaths[entry.getKey()] = entry.getValue(); |
| } |
| |
| //(8)exclusions |
| head[INDEX_exclusions] = (short)(head[INDEX_awtfontpaths] + table_awtfontpaths.length); |
| table_exclusions = new short[scriptIDs.size()]; |
| for (Entry<Short, int[]> entry : exclusions.entrySet()) { |
| int[] exI = entry.getValue(); |
| char[] exC = new char[exI.length * 2]; |
| int j = 0; |
| for (int i = 0; i < exI.length; i++) { |
| exC[j++] = (char) (exI[i] >> 16); |
| exC[j++] = (char) (exI[i] & 0xffff); |
| } |
| table_exclusions[entry.getKey()] = getStringID(new String (exC)); |
| } |
| //(9)proportionals |
| head[INDEX_proportionals] = (short)(head[INDEX_exclusions] + table_exclusions.length); |
| table_proportionals = new short[proportionals.size() * 2]; |
| int j = 0; |
| for (Entry<Short, Short> entry : proportionals.entrySet()) { |
| table_proportionals[j++] = entry.getKey(); |
| table_proportionals[j++] = entry.getValue(); |
| } |
| |
| //(10) see (1) for info, the only difference is "xxx.motif" |
| head[INDEX_scriptFontsMotif] = (short)(head[INDEX_proportionals] + table_proportionals.length); |
| if (scriptAllfontsMotif.size() != 0 || scriptFontsMotif.size() != 0) { |
| len = table_scriptIDs.length + scriptFontsMotif.size() * 20; |
| table_scriptFontsMotif = new short[len]; |
| |
| for (Entry<Short, Short> entry : scriptAllfontsMotif.entrySet()) { |
| table_scriptFontsMotif[entry.getKey().intValue()] = |
| (short)entry.getValue(); |
| } |
| off = table_scriptIDs.length; |
| for (Entry<Short, Short[]> entry : scriptFontsMotif.entrySet()) { |
| table_scriptFontsMotif[entry.getKey().intValue()] = (short)-off; |
| Short[] v = entry.getValue(); |
| int i = 0; |
| while (i < 20) { |
| if (v[i] != null) { |
| table_scriptFontsMotif[off++] = v[i]; |
| } else { |
| table_scriptFontsMotif[off++] = 0; |
| } |
| i++; |
| } |
| } |
| } else { |
| table_scriptFontsMotif = EMPTY_SHORT_ARRAY; |
| } |
| |
| //(11)short[] alphabeticSuffix |
| head[INDEX_alphabeticSuffix] = (short)(head[INDEX_scriptFontsMotif] + table_scriptFontsMotif.length); |
| table_alphabeticSuffix = new short[alphabeticSuffix.size() * 2]; |
| j = 0; |
| for (Entry<Short, Short> entry : alphabeticSuffix.entrySet()) { |
| table_alphabeticSuffix[j++] = entry.getKey(); |
| table_alphabeticSuffix[j++] = entry.getValue(); |
| } |
| |
| //(15)short[] fallbackScriptIDs; just put the ID in head |
| head[INDEX_fallbackScripts] = getShortArrayID(fallbackScriptIDs); |
| |
| //(16)appendedfontpath |
| head[INDEX_appendedfontpath] = getStringID(appendedfontpath); |
| |
| //(17)version |
| head[INDEX_version] = getStringID(version); |
| |
| //(12)short[] StringIDs |
| head[INDEX_stringIDs] = (short)(head[INDEX_alphabeticSuffix] + table_alphabeticSuffix.length); |
| table_stringIDs = new short[stringIDNum + 1]; |
| System.arraycopy(stringIDs, 0, table_stringIDs, 0, stringIDNum + 1); |
| |
| //(13)StringTable |
| head[INDEX_stringTable] = (short)(head[INDEX_stringIDs] + stringIDNum + 1); |
| table_stringTable = stringTable.toString().toCharArray(); |
| //(14) |
| head[INDEX_TABLEEND] = (short)(head[INDEX_stringTable] + stringTable.length()); |
| |
| //StringTable cache |
| stringCache = new String[table_stringIDs.length]; |
| } |
| |
| ////////////////////////////////////////////// |
| private HashMap<String, Short> scriptIDs; |
| //elc -> Encoding.Language.Country |
| private HashMap<String, Short> elcIDs; |
| //componentFontNameID starts from "1", "0" reserves for "undefined" |
| private HashMap<String, Short> componentFontNameIDs; |
| private HashMap<String, Short> fontfileNameIDs; |
| private HashMap<String, Integer> logicalFontIDs; |
| private HashMap<String, Integer> fontStyleIDs; |
| |
| //componentFontNameID -> fontfileNameID |
| private HashMap<Short, Short> filenames; |
| |
| //elcID -> allfonts/logicalFont -> scriptID list |
| //(1)if we have a "allfonts", then the length of the |
| // value array is "1", otherwise it's 5, each font |
| // must have their own individual entry. |
| //scriptID list "short[]" is stored as an ID |
| private HashMap<Short, short[]> sequences; |
| |
| //scriptID ->logicFontID/fontStyleID->componentFontNameID, |
| //a 20-entry array (5-name x 4-style) for each script |
| private HashMap<Short, Short[]> scriptFonts; |
| |
| //scriptID -> componentFontNameID |
| private HashMap<Short, Short> scriptAllfonts; |
| |
| //scriptID -> exclusionRanges[] |
| private HashMap<Short, int[]> exclusions; |
| |
| //scriptID -> fontpath |
| private HashMap<Short, Short> awtfontpaths; |
| |
| //fontID -> fontID |
| private HashMap<Short, Short> proportionals; |
| |
| //scriptID -> componentFontNameID |
| private HashMap<Short, Short> scriptAllfontsMotif; |
| |
| //scriptID ->logicFontID/fontStyleID->componentFontNameID, |
| private HashMap<Short, Short[]> scriptFontsMotif; |
| |
| //elcID -> stringID of alphabetic/XXXX |
| private HashMap<Short, Short> alphabeticSuffix; |
| |
| private short[] fallbackScriptIDs; |
| private String version; |
| private String appendedfontpath; |
| |
| private void initLogicalNameStyle() { |
| logicalFontIDs = new HashMap<String, Integer>(); |
| fontStyleIDs = new HashMap<String, Integer>(); |
| logicalFontIDs.put("serif", 0); |
| logicalFontIDs.put("sansserif", 1); |
| logicalFontIDs.put("monospaced", 2); |
| logicalFontIDs.put("dialog", 3); |
| logicalFontIDs.put("dialoginput",4); |
| fontStyleIDs.put("plain", 0); |
| fontStyleIDs.put("bold", 1); |
| fontStyleIDs.put("italic", 2); |
| fontStyleIDs.put("bolditalic", 3); |
| } |
| |
| private void initHashMaps() { |
| scriptIDs = new HashMap<String, Short>(); |
| elcIDs = new HashMap<String, Short>(); |
| componentFontNameIDs = new HashMap<String, Short>(); |
| /*Init these tables to allow componentFontNameID, fontfileNameIDs |
| to start from "1". |
| */ |
| componentFontNameIDs.put("", Short.valueOf((short)0)); |
| |
| fontfileNameIDs = new HashMap<String, Short>(); |
| filenames = new HashMap<Short, Short>(); |
| sequences = new HashMap<Short, short[]>(); |
| scriptFonts = new HashMap<Short, Short[]>(); |
| scriptAllfonts = new HashMap<Short, Short>(); |
| exclusions = new HashMap<Short, int[]>(); |
| awtfontpaths = new HashMap<Short, Short>(); |
| proportionals = new HashMap<Short, Short>(); |
| scriptFontsMotif = new HashMap<Short, Short[]>(); |
| scriptAllfontsMotif = new HashMap<Short, Short>(); |
| alphabeticSuffix = new HashMap<Short, Short>(); |
| fallbackScriptIDs = EMPTY_SHORT_ARRAY; |
| /* |
| version |
| appendedfontpath |
| */ |
| } |
| |
| private int[] parseExclusions(String key, String exclusions) { |
| if (exclusions == null) { |
| return EMPTY_INT_ARRAY; |
| } |
| // range format is xxxx-XXXX,yyyyyy-YYYYYY,..... |
| int numExclusions = 1; |
| int pos = 0; |
| while ((pos = exclusions.indexOf(',', pos)) != -1) { |
| numExclusions++; |
| pos++; |
| } |
| int[] exclusionRanges = new int[numExclusions * 2]; |
| pos = 0; |
| int newPos = 0; |
| for (int j = 0; j < numExclusions * 2; ) { |
| String lower, upper; |
| int lo = 0, up = 0; |
| try { |
| newPos = exclusions.indexOf('-', pos); |
| lower = exclusions.substring(pos, newPos); |
| pos = newPos + 1; |
| newPos = exclusions.indexOf(',', pos); |
| if (newPos == -1) { |
| newPos = exclusions.length(); |
| } |
| upper = exclusions.substring(pos, newPos); |
| pos = newPos + 1; |
| int lowerLength = lower.length(); |
| int upperLength = upper.length(); |
| if (lowerLength != 4 && lowerLength != 6 |
| || upperLength != 4 && upperLength != 6) { |
| throw new Exception(); |
| } |
| lo = Integer.parseInt(lower, 16); |
| up = Integer.parseInt(upper, 16); |
| if (lo > up) { |
| throw new Exception(); |
| } |
| } catch (Exception e) { |
| if (FontUtilities.debugFonts() && |
| logger != null) { |
| logger.config("Failed parsing " + key + |
| " property of font configuration."); |
| |
| } |
| return EMPTY_INT_ARRAY; |
| } |
| exclusionRanges[j++] = lo; |
| exclusionRanges[j++] = up; |
| } |
| return exclusionRanges; |
| } |
| |
| private Short getID(HashMap<String, Short> map, String key) { |
| Short ret = map.get(key); |
| if ( ret == null) { |
| map.put(key, (short)map.size()); |
| return map.get(key); |
| } |
| return ret; |
| } |
| |
| class FontProperties extends Properties { |
| public synchronized Object put(Object k, Object v) { |
| parseProperty((String)k, (String)v); |
| return null; |
| } |
| } |
| |
| private void parseProperty(String key, String value) { |
| if (key.startsWith("filename.")) { |
| //the only special case is "MingLiu_HKSCS" which has "_" in its |
| //facename, we dont want to replace the "_" with " " |
| key = key.substring(9); |
| if (!"MingLiU_HKSCS".equals(key)) { |
| key = key.replace('_', ' '); |
| } |
| Short faceID = getID(componentFontNameIDs, key); |
| Short fileID = getID(fontfileNameIDs, value); |
| //System.out.println("faceID=" + faceID + "/" + key + " -> " |
| // + "fileID=" + fileID + "/" + value); |
| filenames.put(faceID, fileID); |
| } else if (key.startsWith("exclusion.")) { |
| key = key.substring(10); |
| exclusions.put(getID(scriptIDs,key), parseExclusions(key,value)); |
| } else if (key.startsWith("sequence.")) { |
| key = key.substring(9); |
| boolean hasDefault = false; |
| boolean has1252 = false; |
| |
| //get the scriptID list |
| String[] ss = (String[])splitSequence(value).toArray(EMPTY_STRING_ARRAY); |
| short [] sa = new short[ss.length]; |
| for (int i = 0; i < ss.length; i++) { |
| if ("alphabetic/default".equals(ss[i])) { |
| //System.out.println(key + " -> " + ss[i]); |
| ss[i] = "alphabetic"; |
| hasDefault = true; |
| } else if ("alphabetic/1252".equals(ss[i])) { |
| //System.out.println(key + " -> " + ss[i]); |
| ss[i] = "alphabetic"; |
| has1252 = true; |
| } |
| sa[i] = getID(scriptIDs, ss[i]).shortValue(); |
| //System.out.println("scriptID=" + si[i] + "/" + ss[i]); |
| } |
| //convert the "short[] -> string -> stringID" |
| short scriptArrayID = getShortArrayID(sa); |
| Short elcID = null; |
| int dot = key.indexOf('.'); |
| if (dot == -1) { |
| if ("fallback".equals(key)) { |
| fallbackScriptIDs = sa; |
| return; |
| } |
| if ("allfonts".equals(key)) { |
| elcID = getID(elcIDs, "NULL.NULL.NULL"); |
| } else { |
| if (logger != null) { |
| logger.config("Error sequence def: <sequence." + key + ">"); |
| } |
| return; |
| } |
| } else { |
| elcID = getID(elcIDs, key.substring(dot + 1)); |
| //System.out.println("elcID=" + elcID + "/" + key.substring(dot + 1)); |
| key = key.substring(0, dot); |
| } |
| short[] scriptArrayIDs = null; |
| if ("allfonts".equals(key)) { |
| scriptArrayIDs = new short[1]; |
| scriptArrayIDs[0] = scriptArrayID; |
| } else { |
| scriptArrayIDs = sequences.get(elcID); |
| if (scriptArrayIDs == null) { |
| scriptArrayIDs = new short[5]; |
| } |
| Integer fid = logicalFontIDs.get(key); |
| if (fid == null) { |
| if (logger != null) { |
| logger.config("Unrecognizable logicfont name " + key); |
| } |
| return; |
| } |
| //System.out.println("sequence." + key + "/" + id); |
| scriptArrayIDs[fid.intValue()] = scriptArrayID; |
| } |
| sequences.put(elcID, scriptArrayIDs); |
| if (hasDefault) { |
| alphabeticSuffix.put(elcID, getStringID("default")); |
| } else |
| if (has1252) { |
| alphabeticSuffix.put(elcID, getStringID("1252")); |
| } |
| } else if (key.startsWith("allfonts.")) { |
| key = key.substring(9); |
| if (key.endsWith(".motif")) { |
| key = key.substring(0, key.length() - 6); |
| //System.out.println("motif: all." + key + "=" + value); |
| scriptAllfontsMotif.put(getID(scriptIDs,key), getID(componentFontNameIDs,value)); |
| } else { |
| scriptAllfonts.put(getID(scriptIDs,key), getID(componentFontNameIDs,value)); |
| } |
| } else if (key.startsWith("awtfontpath.")) { |
| key = key.substring(12); |
| //System.out.println("scriptID=" + getID(scriptIDs, key) + "/" + key); |
| awtfontpaths.put(getID(scriptIDs, key), getStringID(value)); |
| } else if ("version".equals(key)) { |
| version = value; |
| } else if ("appendedfontpath".equals(key)) { |
| appendedfontpath = value; |
| } else if (key.startsWith("proportional.")) { |
| key = key.substring(13).replace('_', ' '); |
| //System.out.println(key + "=" + value); |
| proportionals.put(getID(componentFontNameIDs, key), |
| getID(componentFontNameIDs, value)); |
| } else { |
| //"name.style.script(.motif)", we dont care anything else |
| int dot1, dot2; |
| boolean isMotif = false; |
| |
| dot1 = key.indexOf('.'); |
| if (dot1 == -1) { |
| if (logger != null) { |
| logger.config("Failed parsing " + key + |
| " property of font configuration."); |
| |
| } |
| return; |
| } |
| dot2 = key.indexOf('.', dot1 + 1); |
| if (dot2 == -1) { |
| if (logger != null) { |
| logger.config("Failed parsing " + key + |
| " property of font configuration."); |
| |
| } |
| return; |
| } |
| if (key.endsWith(".motif")) { |
| key = key.substring(0, key.length() - 6); |
| isMotif = true; |
| //System.out.println("motif: " + key + "=" + value); |
| } |
| Integer nameID = logicalFontIDs.get(key.substring(0, dot1)); |
| Integer styleID = fontStyleIDs.get(key.substring(dot1+1, dot2)); |
| Short scriptID = getID(scriptIDs, key.substring(dot2 + 1)); |
| if (nameID == null || styleID == null) { |
| if (logger != null) { |
| logger.config("unrecognizable logicfont name/style at " + key); |
| } |
| return; |
| } |
| Short[] pnids; |
| if (isMotif) { |
| pnids = scriptFontsMotif.get(scriptID); |
| } else { |
| pnids = scriptFonts.get(scriptID); |
| } |
| if (pnids == null) { |
| pnids = new Short[20]; |
| } |
| pnids[nameID.intValue() * NUM_STYLES + styleID.intValue()] |
| = getID(componentFontNameIDs, value); |
| /* |
| System.out.println("key=" + key + "/<" + nameID + "><" + styleID |
| + "><" + scriptID + ">=" + value |
| + "/" + getID(componentFontNameIDs, value)); |
| */ |
| if (isMotif) { |
| scriptFontsMotif.put(scriptID, pnids); |
| } else { |
| scriptFonts.put(scriptID, pnids); |
| } |
| } |
| } |
| } |
| } |
