/*

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.font;

import java.awt.Font;

import java.awt.GraphicsEnvironment;

import java.awt.FontFormatException;

import java.io.File;

import java.io.FilenameFilter;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Locale;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.StringTokenizer;

import java.util.TreeMap;

import java.util.Vector;

import java.util.concurrent.ConcurrentHashMap;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.plaf.FontUIResource;

import sun.awt.AppContext;

import sun.awt.FontConfiguration;

import sun.awt.SunHints;

import sun.awt.SunToolkit;

import sun.java2d.HeadlessGraphicsEnvironment;

import sun.java2d.SunGraphicsEnvironment;

import java.awt.geom.GeneralPath;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.lang.reflect.Constructor;

import sun.java2d.Disposer;

/*

 * Interface between Java Fonts (java.awt.Font) and the underlying

 * font files/native font resources and the Java and native font scalers.

 */

public final class FontManager {

    public static final int FONTFORMAT_NONE      = -1;

    public static final int FONTFORMAT_TRUETYPE  = 0;

    public static final int FONTFORMAT_TYPE1     = 1;

    public static final int FONTFORMAT_T2K       = 2;

    public static final int FONTFORMAT_TTC       = 3;

    public static final int FONTFORMAT_COMPOSITE = 4;

    public static final int FONTFORMAT_NATIVE    = 5;

    public static final int NO_FALLBACK         = 0;

    public static final int PHYSICAL_FALLBACK   = 1;

    public static final int LOGICAL_FALLBACK    = 2;

    public static final int QUADPATHTYPE = 1;

    public static final int CUBICPATHTYPE = 2;

    /* Pool of 20 font file channels chosen because some UTF-8 locale

     * composite fonts can use up to 16 platform fonts (including the

     * Lucida fall back). This should prevent channel thrashing when

     * dealing with one of these fonts.

     * The pool array stores the fonts, rather than directly referencing

     * the channels, as the font needs to do the open/close work.

     */

    private static final int CHANNELPOOLSIZE = 20;

    private static int lastPoolIndex = 0;

    private static FileFont fontFileCache[] = new FileFont[CHANNELPOOLSIZE];

    /* Need to implement a simple linked list scheme for fast

     * traversal and lookup.

     * Also want to "fast path" dialog so there's minimal overhead.

     */

    /* There are at exactly 20 composite fonts: 5 faces (but some are not

     * usually different), in 4 styles. The array may be auto-expanded

     * later if more are needed, eg for user-defined composites or locale

     * variants.

     */

    private static int maxCompFont = 0;

    private static CompositeFont [] compFonts = new CompositeFont[20];

    private static ConcurrentHashMap<String, CompositeFont>

        compositeFonts = new ConcurrentHashMap<String, CompositeFont>();

    private static ConcurrentHashMap<String, PhysicalFont>

        physicalFonts = new ConcurrentHashMap<String, PhysicalFont>();

    private static ConcurrentHashMap<String, PhysicalFont>

        registeredFontFiles = new ConcurrentHashMap<String, PhysicalFont>();

    /* given a full name find the Font. Remind: there's duplication

     * here in that this contains the content of compositeFonts +

     * physicalFonts.

     */

    private static ConcurrentHashMap<String, Font2D>

        fullNameToFont = new ConcurrentHashMap<String, Font2D>();

    /* TrueType fonts have localised names. Support searching all

     * of these before giving up on a name.

     */

    private static HashMap<String, TrueTypeFont> localeFullNamesToFont;

    private static PhysicalFont defaultPhysicalFont;

    /* deprecated, unsupported hack - actually invokes a bug! */

    private static boolean usePlatformFontMetrics = false;

    public static Logger logger = null;

    public static boolean logging;

    static boolean longAddresses;

    static String osName;

    static boolean useT2K;

    static boolean isWindows;

    static boolean isSolaris;

    public static boolean isSolaris8; // needed to check for JA wavedash fix.

    public static boolean isSolaris9; // needed to check for songti font usage.

    private static boolean loaded1dot0Fonts = false;

    static SunGraphicsEnvironment sgEnv;

    static boolean loadedAllFonts = false;

    static boolean loadedAllFontFiles = false;

    static TrueTypeFont eudcFont;

    static HashMap<String,String> jreFontMap;

    static HashSet<String> jreLucidaFontFiles;

    static String[] jreOtherFontFiles;

    static boolean noOtherJREFontFiles = false; // initial assumption.

    /* Used to indicate required return type from toArray(..); */

    private static String[] STR_ARRAY = new String[0];

    private static void initJREFontMap() {

        /* Key is familyname+style value as an int.

         * Value is filename containing the font.

         * If no mapping exists, it means there is no font file for the style

         * If the mapping exists but the file doesn't exist in the deferred

         * list then it means its not installed.

         * This looks like a lot of code and strings but if it saves even

         * a single file being opened at JRE start-up there's a big payoff.

         * Lucida Sans is probably the only important case as the others

         * are rarely used. Consider removing the other mappings if there's

         * no evidence they are useful in practice.

         */

        jreFontMap = new HashMap<String,String>();

        jreLucidaFontFiles = new HashSet<String>();

        if (SunGraphicsEnvironment.isOpenJDK()) {

            return;

        }

        /* Lucida Sans Family */

        jreFontMap.put("lucida sans0",   "LucidaSansRegular.ttf");

        jreFontMap.put("lucida sans1",   "LucidaSansDemiBold.ttf");

        /* Lucida Sans full names (map Bold and DemiBold to same file) */

        jreFontMap.put("lucida sans regular0", "LucidaSansRegular.ttf");

        jreFontMap.put("lucida sans regular1", "LucidaSansDemiBold.ttf");

        jreFontMap.put("lucida sans bold1", "LucidaSansDemiBold.ttf");

        jreFontMap.put("lucida sans demibold1", "LucidaSansDemiBold.ttf");

        /* Lucida Sans Typewriter Family */

        jreFontMap.put("lucida sans typewriter0",

                       "LucidaTypewriterRegular.ttf");

        jreFontMap.put("lucida sans typewriter1", "LucidaTypewriterBold.ttf");

        /* Typewriter full names (map Bold and DemiBold to same file) */

        jreFontMap.put("lucida sans typewriter regular0",

                       "LucidaTypewriter.ttf");

        jreFontMap.put("lucida sans typewriter regular1",

                       "LucidaTypewriterBold.ttf");

        jreFontMap.put("lucida sans typewriter bold1",

                       "LucidaTypewriterBold.ttf");

        jreFontMap.put("lucida sans typewriter demibold1",

                       "LucidaTypewriterBold.ttf");

        /* Lucida Bright Family */

        jreFontMap.put("lucida bright0", "LucidaBrightRegular.ttf");

        jreFontMap.put("lucida bright1", "LucidaBrightDemiBold.ttf");

        jreFontMap.put("lucida bright2", "LucidaBrightItalic.ttf");

        jreFontMap.put("lucida bright3", "LucidaBrightDemiItalic.ttf");

        /* Lucida Bright full names (map Bold and DemiBold to same file) */

        jreFontMap.put("lucida bright regular0", "LucidaBrightRegular.ttf");

        jreFontMap.put("lucida bright regular1", "LucidaBrightDemiBold.ttf");

        jreFontMap.put("lucida bright regular2", "LucidaBrightItalic.ttf");

        jreFontMap.put("lucida bright regular3", "LucidaBrightDemiItalic.ttf");

        jreFontMap.put("lucida bright bold1", "LucidaBrightDemiBold.ttf");

        jreFontMap.put("lucida bright bold3", "LucidaBrightDemiItalic.ttf");

        jreFontMap.put("lucida bright demibold1", "LucidaBrightDemiBold.ttf");

        jreFontMap.put("lucida bright demibold3","LucidaBrightDemiItalic.ttf");

        jreFontMap.put("lucida bright italic2", "LucidaBrightItalic.ttf");

        jreFontMap.put("lucida bright italic3", "LucidaBrightDemiItalic.ttf");

        jreFontMap.put("lucida bright bold italic3",

                       "LucidaBrightDemiItalic.ttf");

        jreFontMap.put("lucida bright demibold italic3",

                       "LucidaBrightDemiItalic.ttf");

        for (String ffile : jreFontMap.values()) {

            jreLucidaFontFiles.add(ffile);

        }

    }

    static {

        if (SunGraphicsEnvironment.debugFonts) {

            logger = Logger.getLogger("sun.java2d", null);

            logging = logger.getLevel() != Level.OFF;

        }

        initJREFontMap();

        java.security.AccessController.doPrivileged(

                                    new java.security.PrivilegedAction() {

           public Object run() {

               FontManagerNativeLibrary.load();

               // JNI throws an exception if a class/method/field is not found,

               // so there's no need to do anything explicit here.

               initIDs();

               switch (StrikeCache.nativeAddressSize) {

               case 8: longAddresses = true; break;

               case 4: longAddresses = false; break;

               default: throw new RuntimeException("Unexpected address size");

               }

               osName = System.getProperty("os.name", "unknownOS");

               isSolaris = osName.startsWith("SunOS");

               String t2kStr = System.getProperty("sun.java2d.font.scaler");

               if (t2kStr != null) {

                   useT2K = "t2k".equals(t2kStr);

               }

               if (isSolaris) {

                   String version = System.getProperty("os.version", "unk");

                   isSolaris8 = version.equals("5.8");

                   isSolaris9 = version.equals("5.9");

               } else {

                   isWindows = osName.startsWith("Windows");

                   if (isWindows) {

                       String eudcFile =

                           SunGraphicsEnvironment.eudcFontFileName;

                       if (eudcFile != null) {

                           try {

                               eudcFont = new TrueTypeFont(eudcFile, null, 0,

                                                           true);

                           } catch (FontFormatException e) {

                           }

                       }

                       String prop =

                           System.getProperty("java2d.font.usePlatformFont");

                       if (("true".equals(prop) || getPlatformFontVar())) {

                           usePlatformFontMetrics = true;

                           System.out.println("Enabling platform font metrics for win32. This is an unsupported option.");

                           System.out.println("This yields incorrect composite font metrics as reported by 1.1.x releases.");

                           System.out.println("It is appropriate only for use by applications which do not use any Java 2");

                           System.out.println("functionality. This property will be removed in a later release.");

                       }

                   }

               }

               return null;

           }

        });

    }

    /* Initialise ptrs used by JNI methods */

    private static native void initIDs();

    public static void addToPool(FileFont font) {

        FileFont fontFileToClose = null;

        int freeSlot = -1;

        synchronized (fontFileCache) {

            /* Avoid duplicate entries in the pool, and don't close() it,

             * since this method is called only from within open().

             * Seeing a duplicate is most likely to happen if the thread

             * was interrupted during a read, forcing perhaps repeated

             * close and open calls and it eventually it ends up pointing

             * at the same slot.

             */

            for (int i=0;i<CHANNELPOOLSIZE;i++) {

                if (fontFileCache[i] == font) {

                    return;

                }

                if (fontFileCache[i] == null && freeSlot < 0) {

                    freeSlot = i;

                }

            }

            if (freeSlot >= 0) {

                fontFileCache[freeSlot] = font;

                return;

            } else {

                /* replace with new font. */

                fontFileToClose = fontFileCache[lastPoolIndex];

                fontFileCache[lastPoolIndex] = font;

                /* lastPoolIndex is updated so that the least recently opened

                 * file will be closed next.

                 */

                lastPoolIndex = (lastPoolIndex+1) % CHANNELPOOLSIZE;

            }

        }

        /* Need to close the font file outside of the synchronized block,

         * since its possible some other thread is in an open() call on

         * this font file, and could be holding its lock and the pool lock.

         * Releasing the pool lock allows that thread to continue, so it can

         * then release the lock on this font, allowing the close() call

         * below to proceed.

         * Also, calling close() is safe because any other thread using

         * the font we are closing() synchronizes all reading, so we

         * will not close the file while its in use.

         */

        if (fontFileToClose != null) {

            fontFileToClose.close();

        }

    }

    /*

     * In the normal course of events, the pool of fonts can remain open

     * ready for quick access to their contents. The pool is sized so

     * that it is not an excessive consumer of system resources whilst

     * facilitating performance by providing ready access to the most

     * recently used set of font files.

     * The only reason to call removeFromPool(..) is for a Font that

     * you want to to have GC'd. Currently this would apply only to fonts

     * created with java.awt.Font.createFont(..).

     * In this case, the caller is expected to have arranged for the file

     * to be closed.

     * REMIND: consider how to know when a createFont created font should

     * be closed.

     */

    public static void removeFromPool(FileFont font) {

        synchronized (fontFileCache) {

            for (int i=0; i<CHANNELPOOLSIZE; i++) {

                if (fontFileCache[i] == font) {

                    fontFileCache[i] = null;

                }

            }

        }

    }

    /**

     * This method is provided for internal and exclusive use by Swing.

     *

     * @param font representing a physical font.

     * @return true if the underlying font is a TrueType or OpenType font

     * that claims to support the Microsoft Windows encoding corresponding to

     * the default file.encoding property of this JRE instance.

     * This narrow value is useful for Swing to decide if the font is useful

     * for the the Windows Look and Feel, or, if a  composite font should be

     * used instead.

     * The information used to make the decision is obtained from

     * the ulCodePageRange fields in the font.

     * A caller can use isLogicalFont(Font) in this class before calling

     * this method and would not need to call this method if that

     * returns true.

     */

//     static boolean fontSupportsDefaultEncoding(Font font) {

//      String encoding =

//          (String) java.security.AccessController.doPrivileged(

//                new sun.security.action.GetPropertyAction("file.encoding"));

//      if (encoding == null || font == null) {

//          return false;

//      }

//      encoding = encoding.toLowerCase(Locale.ENGLISH);

//      return FontManager.fontSupportsEncoding(font, encoding);

//     }

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

     */

    public static FontUIResource getCompositeFontUIResource(Font font) {

        FontUIResource fuir =

            new FontUIResource(font.getName(),font.getStyle(),font.getSize());

        Font2D font2D = 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;

        }

        CompositeFont dialog2D =

          (CompositeFont)findFont2D("dialog", font.getStyle(), NO_FALLBACK);

        if (dialog2D == null) { /* shouldn't happen */

            return fuir;

        }

        PhysicalFont physicalFont = (PhysicalFont)font2D;

        CompositeFont compFont = new CompositeFont(physicalFont, dialog2D);

        setFont2D(fuir, compFont.handle);

        /* marking this as a created font is needed as only created fonts

         * copy their creator's handles.

         */

        setCreatedFont(fuir);

        return fuir;

    }

    public static Font2DHandle getNewComposite(String family, int style,

                                               Font2DHandle handle) {

        if (!(handle.font2D instanceof CompositeFont)) {

            return handle;

        }

        CompositeFont oldComp = (CompositeFont)handle.font2D;

        PhysicalFont oldFont = oldComp.getSlotFont(0);

        if (family == null) {

            family = oldFont.getFamilyName(null);

        }

        if (style == -1) {

            style = oldComp.getStyle();

        }

        Font2D newFont = findFont2D(family, style, NO_FALLBACK);

        if (!(newFont instanceof PhysicalFont)) {

            newFont = oldFont;

        }

        PhysicalFont physicalFont = (PhysicalFont)newFont;

        CompositeFont dialog2D =

            (CompositeFont)findFont2D("dialog", style, NO_FALLBACK);

        if (dialog2D == null) { /* shouldn't happen */

            return handle;

        }

        CompositeFont compFont = new CompositeFont(physicalFont, dialog2D);

        Font2DHandle newHandle = new Font2DHandle(compFont);

        return newHandle;

    }

    public static native void setFont2D(Font font, Font2DHandle font2DHandle);

    private static native boolean isCreatedFont(Font font);

    private static native void setCreatedFont(Font font);

    public static void registerCompositeFont(String compositeName,

                                             String[] componentFileNames,

                                             String[] componentNames,

                                             int numMetricsSlots,

                                             int[] exclusionRanges,

                                             int[] exclusionMaxIndex,

                                             boolean defer) {