/* * Copyright (c) 2008, 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.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 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");                 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();        CompositeFont dialog2D =          (CompositeFont) fm.findFont2D("dialog", font.getStyle(),                                        FontManager.NO_FALLBACK);        if (dialog2D == null) { /* shouldn't happen */            return fuir;        }        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) { 

Lines 1–500 of 512. Load more