| /* |
| * Copyright (c) 2008, 2012, 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.font; |
| |
| import java.awt.Font; |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.InputStreamReader; |
| import java.lang.ref.SoftReference; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.security.AccessController; |
| |
| import java.security.PrivilegedAction; |
| import javax.swing.plaf.FontUIResource; |
| |
| import sun.util.logging.PlatformLogger; |
| |
| /** |
| * A collection of utility methods. |
| */ |
| public final class FontUtilities { |
| |
| public static boolean isSolaris; |
| |
| public static boolean isLinux; |
| |
| public static boolean isMacOSX; |
| |
| public static boolean isSolaris8; |
| |
| public static boolean isSolaris9; |
| |
| public static boolean isOpenSolaris; |
| |
| public static boolean useT2K; |
| |
| public static boolean isWindows; |
| |
| public static boolean isOpenJDK; |
| |
| static final String LUCIDA_FILE_NAME = "LucidaSansRegular.ttf"; |
| |
| private static boolean debugFonts = false; |
| private static PlatformLogger logger = null; |
| private static boolean logging; |
| |
| // This static initializer block figures out the OS constants. |
| static { |
| |
| AccessController.doPrivileged(new PrivilegedAction () { |
| public Object run() { |
| String osName = System.getProperty("os.name", "unknownOS"); |
| isSolaris = osName.startsWith("SunOS"); |
| |
| isLinux = osName.startsWith("Linux"); |
| |
| isMacOSX = osName.contains("OS X"); // TODO: MacOSX |
| |
| String t2kStr = System.getProperty("sun.java2d.font.scaler"); |
| if (t2kStr != null) { |
| useT2K = "t2k".equals(t2kStr); |
| } else { |
| useT2K = false; |
| } |
| if (isSolaris) { |
| String version = System.getProperty("os.version", "0.0"); |
| isSolaris8 = version.startsWith("5.8"); |
| isSolaris9 = version.startsWith("5.9"); |
| float ver = Float.parseFloat(version); |
| if (ver > 5.10f) { |
| File f = new File("/etc/release"); |
| String line = null; |
| try { |
| FileInputStream fis = new FileInputStream(f); |
| InputStreamReader isr = new InputStreamReader( |
| fis, "ISO-8859-1"); |
| BufferedReader br = new BufferedReader(isr); |
| line = br.readLine(); |
| fis.close(); |
| } catch (Exception ex) { |
| // Nothing to do here. |
| } |
| if (line != null && line.indexOf("OpenSolaris") >= 0) { |
| isOpenSolaris = true; |
| } else { |
| isOpenSolaris = false; |
| } |
| } else { |
| isOpenSolaris = false; |
| } |
| } else { |
| isSolaris8 = false; |
| isSolaris9 = false; |
| isOpenSolaris = false; |
| } |
| isWindows = osName.startsWith("Windows"); |
| String jreLibDirName = System.getProperty("java.home", "") |
| + File.separator + "lib"; |
| String jreFontDirName = |
| jreLibDirName + File.separator + "fonts"; |
| File lucidaFile = new File(jreFontDirName + File.separator |
| + LUCIDA_FILE_NAME); |
| isOpenJDK = !lucidaFile.exists(); |
| |
| String debugLevel = |
| System.getProperty("sun.java2d.debugfonts"); |
| |
| if (debugLevel != null && !debugLevel.equals("false")) { |
| debugFonts = true; |
| logger = PlatformLogger.getLogger("sun.java2d"); |
| if (debugLevel.equals("warning")) { |
| logger.setLevel(PlatformLogger.WARNING); |
| } else if (debugLevel.equals("severe")) { |
| logger.setLevel(PlatformLogger.SEVERE); |
| } |
| } |
| |
| if (debugFonts) { |
| logger = PlatformLogger.getLogger("sun.java2d"); |
| logging = logger.isEnabled(); |
| } |
| |
| return null; |
| } |
| }); |
| } |
| |
| /** |
| * Referenced by code in the JDK which wants to test for the |
| * minimum char code for which layout may be required. |
| * Note that even basic latin text can benefit from ligatures, |
| * eg "ffi" but we presently apply those only if explicitly |
| * requested with TextAttribute.LIGATURES_ON. |
| * The value here indicates the lowest char code for which failing |
| * to invoke layout would prevent acceptable rendering. |
| */ |
| public static final int MIN_LAYOUT_CHARCODE = 0x0300; |
| |
| /** |
| * Referenced by code in the JDK which wants to test for the |
| * maximum char code for which layout may be required. |
| * Note this does not account for supplementary characters |
| * where the caller interprets 'layout' to mean any case where |
| * one 'char' (ie the java type char) does not map to one glyph |
| */ |
| public static final int MAX_LAYOUT_CHARCODE = 0x206F; |
| |
| /** |
| * Calls the private getFont2D() method in java.awt.Font objects. |
| * |
| * @param font the font object to call |
| * |
| * @return the Font2D object returned by Font.getFont2D() |
| */ |
| public static Font2D getFont2D(Font font) { |
| return FontAccess.getFontAccess().getFont2D(font); |
| } |
| |
| /** |
| * If there is anything in the text which triggers a case |
| * where char->glyph does not map 1:1 in straightforward |
| * left->right ordering, then this method returns true. |
| * Scripts which might require it but are not treated as such |
| * due to JDK implementations will not return true. |
| * ie a 'true' return is an indication of the treatment by |
| * the implementation. |
| * Whether supplementary characters should be considered is dependent |
| * on the needs of the caller. Since this method accepts the 'char' type |
| * then such chars are always represented by a pair. From a rendering |
| * perspective these will all (in the cases I know of) still be one |
| * unicode character -> one glyph. But if a caller is using this to |
| * discover any case where it cannot make naive assumptions about |
| * the number of chars, and how to index through them, then it may |
| * need the option to have a 'true' return in such a case. |
| */ |
| public static boolean isComplexText(char [] chs, int start, int limit) { |
| |
| for (int i = start; i < limit; i++) { |
| if (chs[i] < MIN_LAYOUT_CHARCODE) { |
| continue; |
| } |
| else if (isNonSimpleChar(chs[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /* This is almost the same as the method above, except it takes a |
| * char which means it may include undecoded surrogate pairs. |
| * The distinction is made so that code which needs to identify all |
| * cases in which we do not have a simple mapping from |
| * char->unicode character->glyph can be be identified. |
| * For example measurement cannot simply sum advances of 'chars', |
| * the caret in editable text cannot advance one 'char' at a time, etc. |
| * These callers really are asking for more than whether 'layout' |
| * needs to be run, they need to know if they can assume 1->1 |
| * char->glyph mapping. |
| */ |
| public static boolean isNonSimpleChar(char ch) { |
| return |
| isComplexCharCode(ch) || |
| (ch >= CharToGlyphMapper.HI_SURROGATE_START && |
| ch <= CharToGlyphMapper.LO_SURROGATE_END); |
| } |
| |
| /* If the character code falls into any of a number of unicode ranges |
| * where we know that simple left->right layout mapping chars to glyphs |
| * 1:1 and accumulating advances is going to produce incorrect results, |
| * we want to know this so the caller can use a more intelligent layout |
| * approach. A caller who cares about optimum performance may want to |
| * check the first case and skip the method call if its in that range. |
| * Although there's a lot of tests in here, knowing you can skip |
| * CTL saves a great deal more. The rest of the checks are ordered |
| * so that rather than checking explicitly if (>= start & <= end) |
| * which would mean all ranges would need to be checked so be sure |
| * CTL is not needed, the method returns as soon as it recognises |
| * the code point is outside of a CTL ranges. |
| * NOTE: Since this method accepts an 'int' it is asssumed to properly |
| * represent a CHARACTER. ie it assumes the caller has already |
| * converted surrogate pairs into supplementary characters, and so |
| * can handle this case and doesn't need to be told such a case is |
| * 'complex'. |
| */ |
| public static boolean isComplexCharCode(int code) { |
| |
| if (code < MIN_LAYOUT_CHARCODE || code > MAX_LAYOUT_CHARCODE) { |
| return false; |
| } |
| else if (code <= 0x036f) { |
| // Trigger layout for combining diacriticals 0x0300->0x036f |
| return true; |
| } |
| else if (code < 0x0590) { |
| // No automatic layout for Greek, Cyrillic, Armenian. |
| return false; |
| } |
| else if (code <= 0x06ff) { |
| // Hebrew 0590 - 05ff |
| // Arabic 0600 - 06ff |
| return true; |
| } |
| else if (code < 0x0900) { |
| return false; // Syriac and Thaana |
| } |
| else if (code <= 0x0e7f) { |
| // if Indic, assume shaping for conjuncts, reordering: |
| // 0900 - 097F Devanagari |
| // 0980 - 09FF Bengali |
| // 0A00 - 0A7F Gurmukhi |
| // 0A80 - 0AFF Gujarati |
| // 0B00 - 0B7F Oriya |
| // 0B80 - 0BFF Tamil |
| // 0C00 - 0C7F Telugu |
| // 0C80 - 0CFF Kannada |
| // 0D00 - 0D7F Malayalam |
| // 0D80 - 0DFF Sinhala |
| // 0E00 - 0E7F if Thai, assume shaping for vowel, tone marks |
| return true; |
| } |
| else if (code < 0x0f00) { |
| return false; |
| } |
| else if (code <= 0x0fff) { // U+0F00 - U+0FFF Tibetan |
| return true; |
| } |
| else if (code < 0x1100) { |
| return false; |
| } |
| else if (code < 0x11ff) { // U+1100 - U+11FF Old Hangul |
| return true; |
| } |
| else if (code < 0x1780) { |
| return false; |
| } |
| else if (code <= 0x17ff) { // 1780 - 17FF Khmer |
| return true; |
| } |
| else if (code < 0x200c) { |
| return false; |
| } |
| else if (code <= 0x200d) { // zwj or zwnj |
| return true; |
| } |
| else if (code >= 0x202a && code <= 0x202e) { // directional control |
| return true; |
| } |
| else if (code >= 0x206a && code <= 0x206f) { // directional control |
| return true; |
| } |
| return false; |
| } |
| |
| public static PlatformLogger getLogger() { |
| return logger; |
| } |
| |
| public static boolean isLogging() { |
| return logging; |
| } |
| |
| public static boolean debugFonts() { |
| return debugFonts; |
| } |
| |
| |
| // The following methods are used by Swing. |
| |
| /* Revise the implementation to in fact mean "font is a composite font. |
| * This ensures that Swing components will always benefit from the |
| * fall back fonts |
| */ |
| public static boolean fontSupportsDefaultEncoding(Font font) { |
| return getFont2D(font) instanceof CompositeFont; |
| } |
| |
| /** |
| * This method is provided for internal and exclusive use by Swing. |
| * |
| * It may be used in conjunction with fontSupportsDefaultEncoding(Font) |
| * In the event that a desktop properties font doesn't directly |
| * support the default encoding, (ie because the host OS supports |
| * adding support for the current locale automatically for native apps), |
| * then Swing calls this method to get a font which uses the specified |
| * font for the code points it covers, but also supports this locale |
| * just as the standard composite fonts do. |
| * Note: this will over-ride any setting where an application |
| * specifies it prefers locale specific composite fonts. |
| * The logic for this, is that this method is used only where the user or |
| * application has specified that the native L&F be used, and that |
| * we should honour that request to use the same font as native apps use. |
| * |
| * The behaviour of this method is to construct a new composite |
| * Font object that uses the specified physical font as its first |
| * component, and adds all the components of "dialog" as fall back |
| * components. |
| * The method currently assumes that only the size and style attributes |
| * are set on the specified font. It doesn't copy the font transform or |
| * other attributes because they aren't set on a font created from |
| * the desktop. This will need to be fixed if use is broadened. |
| * |
| * Operations such as Font.deriveFont will work properly on the |
| * font returned by this method for deriving a different point size. |
| * Additionally it tries to support a different style by calling |
| * getNewComposite() below. That also supports replacing slot zero |
| * with a different physical font but that is expected to be "rare". |
| * Deriving with a different style is needed because its been shown |
| * that some applications try to do this for Swing FontUIResources. |
| * Also operations such as new Font(font.getFontName(..), Font.PLAIN, 14); |
| * will NOT yield the same result, as the new underlying CompositeFont |
| * cannot be "looked up" in the font registry. |
| * This returns a FontUIResource as that is the Font sub-class needed |
| * by Swing. |
| * Suggested usage is something like : |
| * FontUIResource fuir; |
| * Font desktopFont = getDesktopFont(..); |
| * // NOTE even if fontSupportsDefaultEncoding returns true because |
| * // you get Tahoma and are running in an English locale, you may |
| * // still want to just call getCompositeFontUIResource() anyway |
| * // as only then will you get fallback fonts - eg for CJK. |
| * if (FontManager.fontSupportsDefaultEncoding(desktopFont)) { |
| * fuir = new FontUIResource(..); |
| * } else { |
| * fuir = FontManager.getCompositeFontUIResource(desktopFont); |
| * } |
| * return fuir; |
| */ |
| private static volatile |
| SoftReference<ConcurrentHashMap<PhysicalFont, CompositeFont>> |
| compMapRef = new SoftReference(null); |
| |
| public static FontUIResource getCompositeFontUIResource(Font font) { |
| |
| FontUIResource fuir = new FontUIResource(font); |
| Font2D font2D = FontUtilities.getFont2D(font); |
| |
| if (!(font2D instanceof PhysicalFont)) { |
| /* Swing should only be calling this when a font is obtained |
| * from desktop properties, so should generally be a physical font, |
| * an exception might be for names like "MS Serif" which are |
| * automatically mapped to "Serif", so there's no need to do |
| * anything special in that case. But note that suggested usage |
| * is first to call fontSupportsDefaultEncoding(Font) and this |
| * method should not be called if that were to return true. |
| */ |
| return fuir; |
| } |
| |
| FontManager fm = FontManagerFactory.getInstance(); |
| Font2D dialog = fm.findFont2D("dialog", font.getStyle(), FontManager.NO_FALLBACK); |
| // Should never be null, but MACOSX fonts are not CompositeFonts |
| if (dialog == null || !(dialog instanceof CompositeFont)) { |
| return fuir; |
| } |
| CompositeFont dialog2D = (CompositeFont)dialog; |
| PhysicalFont physicalFont = (PhysicalFont)font2D; |
| ConcurrentHashMap<PhysicalFont, CompositeFont> compMap = compMapRef.get(); |
| if (compMap == null) { // Its been collected. |
| compMap = new ConcurrentHashMap<PhysicalFont, CompositeFont>(); |
| compMapRef = new SoftReference(compMap); |
| } |
| CompositeFont compFont = compMap.get(physicalFont); |
| if (compFont == null) { |
| compFont = new CompositeFont(physicalFont, dialog2D); |
| compMap.put(physicalFont, compFont); |
| } |
| FontAccess.getFontAccess().setFont2D(fuir, compFont.handle); |
| /* marking this as a created font is needed as only created fonts |
| * copy their creator's handles. |
| */ |
| FontAccess.getFontAccess().setCreatedFont(fuir); |
| return fuir; |
| } |
| |
| /* A small "map" from GTK/fontconfig names to the equivalent JDK |
| * logical font name. |
| */ |
| private static final String[][] nameMap = { |
| {"sans", "sansserif"}, |
| {"sans-serif", "sansserif"}, |
| {"serif", "serif"}, |
| {"monospace", "monospaced"} |
| }; |
| |
| public static String mapFcName(String name) { |
| for (int i = 0; i < nameMap.length; i++) { |
| if (name.equals(nameMap[i][0])) { |
| return nameMap[i][1]; |
| } |
| } |
| return null; |
| } |
| |
| |
| /* This is called by Swing passing in a fontconfig family name |
| * such as "sans". In return Swing gets a FontUIResource instance |
| * that has queried fontconfig to resolve the font(s) used for this. |
| * Fontconfig will if asked return a list of fonts to give the largest |
| * possible code point coverage. |
| * For now we use only the first font returned by fontconfig, and |
| * back it up with the most closely matching JDK logical font. |
| * Essentially this means pre-pending what we return now with fontconfig's |
| * preferred physical font. This could lead to some duplication in cases, |
| * if we already included that font later. We probably should remove such |
| * duplicates, but it is not a significant problem. It can be addressed |
| * later as part of creating a Composite which uses more of the |
| * same fonts as fontconfig. At that time we also should pay more |
| * attention to the special rendering instructions fontconfig returns, |
| * such as whether we should prefer embedded bitmaps over antialiasing. |
| * There's no way to express that via a Font at present. |
| */ |
| public static FontUIResource getFontConfigFUIR(String fcFamily, |
| int style, int size) { |
| |
| String mapped = mapFcName(fcFamily); |
| if (mapped == null) { |
| mapped = "sansserif"; |
| } |
| |
| FontUIResource fuir; |
| FontManager fm = FontManagerFactory.getInstance(); |
| if (fm instanceof SunFontManager) { |
| SunFontManager sfm = (SunFontManager) fm; |
| fuir = sfm.getFontConfigFUIR(mapped, style, size); |
| } else { |
| fuir = new FontUIResource(mapped, style, size); |
| } |
| return fuir; |
| } |
| |
| |
| /** |
| * Used by windows printing to assess if a font is likely to |
| * be layout compatible with JDK |
| * TrueType fonts should be, but if they have no GPOS table, |
| * but do have a GSUB table, then they are probably older |
| * fonts GDI handles differently. |
| */ |
| public static boolean textLayoutIsCompatible(Font font) { |
| |
| Font2D font2D = getFont2D(font); |
| if (font2D instanceof TrueTypeFont) { |
| TrueTypeFont ttf = (TrueTypeFont) font2D; |
| return |
| ttf.getDirectoryEntry(TrueTypeFont.GSUBTag) == null || |
| ttf.getDirectoryEntry(TrueTypeFont.GPOSTag) != null; |
| } else { |
| return false; |
| } |
| } |
| |
| } |
