jdk-sandbox: comparison jdk/src/share/classes/sun/font/FontManager.java

equal deleted inserted replaced

-:53b7ee7d67b5
+:6549643c008c
 static TrueTypeFont eudcFont;
 static HashMap<String,String> jreFontMap;
 static HashSet<String> jreLucidaFontFiles;
 static String[] jreOtherFontFiles;
 static boolean noOtherJREFontFiles = false; // initial assumption.
+static boolean fontConfigFailed = false;
 /* Used to indicate required return type from toArray(..); */
 private static String[] STR_ARRAY = new String[0];
 private static void initJREFontMap() {
 "monospace:bold:roman",
 "monospace:regular:italic",
 "monospace:bold:italic",
 };
-/* This class is just a data structure.
+/* These next three classes are just data structures.
 */
-private static class FontConfigInfo {
+static class FontConfigFont {
+String familyName;        // eg Bitstream Vera Sans
+String styleStr;          // eg Bold
+String fullName;          // eg Bitstream Vera Sans Bold
+String fontFile;          // eg /usr/X11/lib/fonts/foo.ttf
+}
+static class FcCompFont {
 String fcName;            // eg sans
 String fcFamily;          // eg sans
 String jdkName;           // eg sansserif
 int style;                // eg 0=PLAIN
-String familyName;        // eg Bitstream Vera Sans
+FontConfigFont firstFont;
-String fontFile;          // eg /usr/X11/lib/fonts/foo.ttf
+FontConfigFont[] allFonts;
 //boolean preferBitmaps;    // if embedded bitmaps preferred over AA
 CompositeFont compFont;   // null if not yet created/known.
 }
+static class FontConfigInfo {
+int fcVersion;
+String[] cacheDirs = new String[4];
+}
 private static String getFCLocaleStr() {
 Locale l = SunToolkit.getStartupLocale();
 String localeStr = l.getLanguage();
 String country = l.getCountry();
 if (!country.equals("")) {
 localeStr = localeStr + "-" + country;
 }
 return localeStr;
 }
+/* This does cause the native libfontconfig to be loaded and unloaded,
+* but it does not incur the overhead of initialisation of its
+* data structures, so shouldn't have a measurable impact.
+*/
+public static native int getFontConfigVersion();
 private static native int
 getFontConfigAASettings(String locale, String fcFamily);
 /* This is public solely so that for debugging purposes it can be called
 */
 public static Object getFontConfigAAHint() {
 return getFontConfigAAHint("sans");
 }
+/* This is populated by native */
+private static final FontConfigInfo fcInfo = new FontConfigInfo();
 /* This array has the array elements created in Java code and is
 * passed down to native to be filled in.
 */
-private static FontConfigInfo[] fontConfigFonts;
+private static FcCompFont[] fontConfigFonts;
-/* Return an array of FontConfigInfo structs describing the primary
+/* Return an array of FcCompFont structs describing the primary
 * font located for each of fontconfig/GTK/Pango's logical font names.
 */
 private static native void getFontConfig(String locale,
-FontConfigInfo[] fonts);
+FontConfigInfo fcInfo,
+FcCompFont[] fonts,
+boolean includeFallbacks);
+static void populateFontConfig(FcCompFont[] fcInfo) {
+fontConfigFonts = fcInfo;
+}
+static FcCompFont[] loadFontConfig() {
+initFontConfigFonts(true);
+return fontConfigFonts;
+}
+static FontConfigInfo getFontConfigInfo() {
+initFontConfigFonts(true);
+return fcInfo;
+}
 /* This can be made public if it's needed to force a re-read
 * rather than using the cached values. The re-read would be needed
 * only if some event signalled that the fontconfig has changed.
 * In that event this method would need to return directly the array
 * to be used by the caller in case it subsequently changed.
 */
-private static void initFontConfigFonts() {
+private static synchronized void
+initFontConfigFonts(boolean includeFallbacks) {
 if (fontConfigFonts != null) {
-return;
+if (!includeFallbacks || (fontConfigFonts[0].allFonts != null)) {
-}
+return;
+}
-if (isWindows) {
+}
+if (isWindows || fontConfigFailed) {
 return;
 }
 long t0 = 0;
 if (logging) {
-t0 = System.currentTimeMillis();
+t0 = System.nanoTime();
 }
-FontConfigInfo[] fontArr = new FontConfigInfo[fontConfigNames.length];
+FcCompFont[] fontArr = new FcCompFont[fontConfigNames.length];
 for (int i = 0; i< fontArr.length; i++) {
-fontArr[i] = new FontConfigInfo();
+fontArr[i] = new FcCompFont();
 fontArr[i].fcName = fontConfigNames[i];
 int colonPos = fontArr[i].fcName.indexOf(':');
 fontArr[i].fcFamily = fontArr[i].fcName.substring(0, colonPos);
 fontArr[i].jdkName = mapFcName(fontArr[i].fcFamily);
 fontArr[i].style = i % 4; // depends on array order.
 }
-getFontConfig(getFCLocaleStr(), fontArr);
+getFontConfig(getFCLocaleStr(), fcInfo, fontArr, includeFallbacks);
+/* If don't find anything (eg no libfontconfig), then just return */
+for (int i = 0; i< fontArr.length; i++) {
+FcCompFont fci = fontArr[i];
+if (fci.firstFont == null) {
+if (logging) {
+logger.info("Fontconfig returned no fonts.");
+}
+fontConfigFailed = true;
+return;
+}
+}
 fontConfigFonts = fontArr;
 if (logging) {
-long t1 = System.currentTimeMillis();
+long t1 = System.nanoTime();
-logger.info("Time spent accessing fontconfig="+(t1-t0)+"ms.");
+logger.info("Time spent accessing fontconfig="+
+(t1-t0)/1000000+"ms.");
 for (int i = 0; i< fontConfigFonts.length; i++) {
-FontConfigInfo fci = fontConfigFonts[i];
+FcCompFont fci = fontConfigFonts[i];
 logger.info("FC font " + fci.fcName+" maps to family " +
-fci.familyName + " in file " + fci.fontFile);
+fci.firstFont.familyName +
-}
+" in file " + fci.firstFont.fontFile);
-}
+if (fci.allFonts != null) {
-}
+for (int f=0;f<fci.allFonts.length;f++) {
+FontConfigFont fcf = fci.allFonts[f];
-private static PhysicalFont registerFromFcInfo(FontConfigInfo fcInfo) {
+logger.info("Family=" + fcf.familyName +
+" Style="+ fcf.styleStr +
+" Fullname="+fcf.fullName +
+" File="+fcf.fontFile);
+}
+}
+}
+}
+}
+private static PhysicalFont registerFromFcInfo(FcCompFont fcInfo) {
 /* If it's a TTC file we need to know that as we will need to
 * make sure we return the right font */
-int offset = fcInfo.fontFile.length()-4;
+String fontFile = fcInfo.firstFont.fontFile;
+int offset = fontFile.length()-4;
 if (offset <= 0) {
 return null;
 }
-String ext = fcInfo.fontFile.substring(offset).toLowerCase();
+String ext = fontFile.substring(offset).toLowerCase();
 boolean isTTC = ext.equals(".ttc");
 /* If this file is already registered, can just return its font.
 * However we do need to check in case it's a TTC as we need
 * a specific font, so rather than directly returning it, let
 * findFont2D resolve that.
 */
-PhysicalFont physFont = registeredFontFiles.get(fcInfo.fontFile);
+PhysicalFont physFont = registeredFontFiles.get(fontFile);
 if (physFont != null) {
 if (isTTC) {
-Font2D f2d = findFont2D(fcInfo.familyName,
+Font2D f2d = findFont2D(fcInfo.firstFont.familyName,
 fcInfo.style, NO_FALLBACK);
 if (f2d instanceof PhysicalFont) { /* paranoia */
 return (PhysicalFont)f2d;
 } else {
 return null;
 /* If the font may hide a JRE font (eg fontconfig says it is
 * Lucida Sans), we want to use the JRE version, so make it
 * point to the JRE font.
 */
-physFont = findJREDeferredFont(fcInfo.familyName, fcInfo.style);
+physFont = findJREDeferredFont(fcInfo.firstFont.familyName,
+fcInfo.style);
 /* It is also possible the font file is on the "deferred" list,
 * in which case we can just initialise it now.
 */
 if (physFont == null &&
-deferredFontFiles.get(fcInfo.fontFile) != null) {
+deferredFontFiles.get(fontFile) != null)
-physFont = initialiseDeferredFont(fcInfo.fontFile);
+{
+physFont = initialiseDeferredFont(fcInfo.firstFont.fontFile);
 /* use findFont2D to get the right font from TTC's */
 if (physFont != null) {
 if (isTTC) {
-Font2D f2d = findFont2D(fcInfo.familyName,
+Font2D f2d = findFont2D(fcInfo.firstFont.familyName,
 fcInfo.style, NO_FALLBACK);
 if (f2d instanceof PhysicalFont) { /* paranoia */
 return (PhysicalFont)f2d;
 } else {
 return null;
 fontRank = Font2D.TTF_RANK;
 } else if (ext.equals(".pfa") || ext.equals(".pfb")) {
 fontFormat = FONTFORMAT_TYPE1;
 fontRank = Font2D.TYPE1_RANK;
 }
-physFont = registerFontFile(fcInfo.fontFile, null,
+physFont = registerFontFile(fcInfo.firstFont.fontFile, null,
 fontFormat, true, fontRank);
 }
 return physFont;
 }
 } else {
 info[1] = dirs[0];
 }
 info[1] = info[1] + File.separator + "arial.ttf";
 } else {
-initFontConfigFonts();
+initFontConfigFonts(false);
 for (int i=0; i<fontConfigFonts.length; i++) {
 if ("sans".equals(fontConfigFonts[i].fcFamily) &&
 0 == fontConfigFonts[i].style) {
-info[0] = fontConfigFonts[i].familyName;
+info[0] = fontConfigFonts[i].firstFont.familyName;
-info[1] = fontConfigFonts[i].fontFile;
+info[1] = fontConfigFonts[i].firstFont.fontFile;
 break;
 }
 }
 /* Absolute last ditch attempt in the face of fontconfig problems.
 * If we didn't match, pick the first, or just make something
 * up so we don't NPE.
 */
 if (info[0] == null) {
 if (fontConfigFonts.length > 0 &&
-fontConfigFonts[0].fontFile != null) {
+fontConfigFonts[0].firstFont.fontFile != null) {
-info[0] = fontConfigFonts[0].familyName;
+info[0] = fontConfigFonts[0].firstFont.familyName;
-info[1] = fontConfigFonts[0].fontFile;
+info[1] = fontConfigFonts[0].firstFont.fontFile;
 } else {
 info[0] = "Dialog";
 info[1] = "/dialog.ttf";
 }
 }
 }
 defaultPlatformFont = info;
 return defaultPlatformFont;
 }
-private FontConfigInfo getFontConfigInfo() {
+private FcCompFont getFcCompFont() {
-initFontConfigFonts();
+initFontConfigFonts(false);
 for (int i=0; i<fontConfigFonts.length; i++) {
 if ("sans".equals(fontConfigFonts[i].fcFamily) &&
 0 == fontConfigFonts[i].style) {
 return fontConfigFonts[i];
 }
 */
 private static CompositeFont getFontConfigFont(String name, int style) {
 name = name.toLowerCase();
-initFontConfigFonts();
+initFontConfigFonts(false);
-FontConfigInfo fcInfo = null;
+FcCompFont fcInfo = null;
 for (int i=0; i<fontConfigFonts.length; i++) {
 if (name.equals(fontConfigFonts[i].fcFamily) &&
 style == fontConfigFonts[i].style) {
 fcInfo = fontConfigFonts[i];
 break;
 fcInfo = fontConfigFonts[0];
 }
 if (logging) {
 logger.info("FC name=" + name + " style=" + style + " uses " +
-fcInfo.familyName + " in file: " + fcInfo.fontFile);
+fcInfo.firstFont.familyName +
+" in file: " + fcInfo.firstFont.fontFile);
 }
 if (fcInfo.compFont != null) {
 return fcInfo.compFont;
 }
 * Slot 0 will be the physical font from fontconfig.
 */
 CompositeFont jdkFont = (CompositeFont)
 findFont2D(fcInfo.jdkName, style, LOGICAL_FALLBACK);
-if (fcInfo.familyName == null || fcInfo.fontFile == null) {
+if (fcInfo.firstFont.familyName == null ||
+fcInfo.firstFont.fontFile == null) {
 return (fcInfo.compFont = jdkFont);
 }
 /* First, see if the family and exact style is already registered.
 * If it is, use it. If it's not, then try to register it.
 * regular JDK composite.
 * Algorithmically styled fonts won't match on exact style, so
 * will fall through this code, but the regisration code will
 * find that file already registered and return its font.
 */
-FontFamily family = FontFamily.getFamily(fcInfo.familyName);
+FontFamily family = FontFamily.getFamily(fcInfo.firstFont.familyName);
 PhysicalFont physFont = null;
 if (family != null) {
 Font2D f2D = family.getFontWithExactStyleMatch(fcInfo.style);
 if (f2D instanceof PhysicalFont) {
 physFont = (PhysicalFont)f2D;
 }
 }
-if (physFont == null || !fcInfo.fontFile.equals(physFont.platName)) {
+if (physFont == null ||
+!fcInfo.firstFont.fontFile.equals(physFont.platName)) {
 physFont = registerFromFcInfo(fcInfo);
 if (physFont == null) {
 return (fcInfo.compFont = jdkFont);
 }
 family = FontFamily.getFamily(physFont.getFamilyName(null));
 * Assume that all styles of this font are found by fontconfig,
 * so we can find all the family members which must be registered
 * together to prevent synthetic styling.
 */
 for (int i=0; i<fontConfigFonts.length; i++) {
-FontConfigInfo fc = fontConfigFonts[i];
+FcCompFont fc = fontConfigFonts[i];
 if (fc != fcInfo &&
-physFont.getFamilyName(null).equals(fc.familyName) &&
+physFont.getFamilyName(null).equals(fc.firstFont.familyName) &&
-!fc.fontFile.equals(physFont.platName) &&
+!fc.firstFont.fontFile.equals(physFont.platName) &&
 family.getFontWithExactStyleMatch(fc.style) == null) {
 registerFromFcInfo(fontConfigFonts[i]);
 }
 }

changeset 889	6549643c008c
parent 715	f16baef3a20e
parent 883	c3e81f0acd3d
child 1721	7a86d7e13fdf