/*
* 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);
}
}
}
}
}