/*

 * 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) {

        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;

        }

    }

}