/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  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.  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.awt;

import java.awt.GraphicsDevice;

import java.awt.Point;

import java.awt.Rectangle;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.io.IOException;

import java.io.StreamTokenizer;

import java.net.InetAddress;

import java.net.NetworkInterface;

import java.net.SocketException;

import java.net.UnknownHostException;

import java.util.*;

import java.util.logging.*;

import sun.awt.motif.MFontConfiguration;

import sun.font.Font2D;

import sun.font.FontManager;

import sun.font.NativeFont;

import sun.java2d.SunGraphicsEnvironment;

/**

 * This is an implementation of a GraphicsEnvironment object for the

 * default local GraphicsEnvironment used by the Java Runtime Environment

 * for X11 environments.

 *

 * @see GraphicsDevice

 * @see GraphicsConfiguration

 */

public class X11GraphicsEnvironment

    extends SunGraphicsEnvironment

{

    private static final Logger log = Logger.getLogger("sun.awt.X11GraphicsEnvironment");

    private static final Logger screenLog = Logger.getLogger("sun.awt.screen.X11GraphicsEnvironment");

    private static Boolean xinerState;

    /*

     * This is the set of font directories needed to be on the X font path

     * to enable AWT heavyweights to find all of the font configuration fonts.

     * It is populated by :

     * - awtfontpath entries in the fontconfig.properties

     * - parent directories of "core" fonts used in the fontconfig.properties

     * - looking up font dirs in the xFontDirsMap where the key is a fontID

     *   (cut down version of the XLFD read from the font configuration file).

     * This set is nulled out after use to free heap space.

     */

    private static HashSet<String> fontConfigDirs = null;

   /*

    * fontNameMap is a map from a fontID (which is a substring of an XLFD like

    * "-monotype-arial-bold-r-normal-iso8859-7")

    * to font file path like

    * /usr/openwin/lib/locale/iso_8859_7/X11/fonts/TrueType/ArialBoldItalic.ttf

    * It's used in a couple of methods like

    * getFileNameFomPlatformName(..) to help locate the font file.

    * We use this substring of a full XLFD because the font configuration files

    * define the XLFDs in a way that's easier to make into a request.

    * E.g., the -0-0-0-0-p-0- reported by X is -*-%d-*-*-p-*- in the font

    * configuration files. We need to remove that part for comparisons.

    */

    private static Map fontNameMap = new HashMap();

    /* xFontDirsMap is also a map from a font ID to a font filepath.

     * The difference from fontNameMap is just that it does not have

     * resolved symbolic links. Normally this is not interesting except

     * that we need to know the directory in which a font was found to

     * add it to the X font server path, since although the files may

     * be linked, the fonts.dir is different and specific to the encoding

     * handled by that directory. This map is nulled out after use to free

     * heap space. If the optimal path is taken, such that all fonts in

     * font configuration files are referenced by filename, then the font

     * dir can be directly derived as its parent directory.

     * If a font is used by two XLFDs, each corresponding to a different

     * X11 font directory, then precautions must be taken to include both

     * directories.

     */

     private static Map xFontDirsMap;

    /*

     * xlfdMap is a map from a platform path like

     * /usr/openwin/lib/locale/ja/X11/fonts/TT/HG-GothicB.ttf to an XLFD like

     * "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"

     * Because there may be multiple native names, because the font is used

     * to support multiple X encodings for example, the value of an entry in

     * this map is always a vector where we store all the native names.

     * For fonts which we don't understand the key isn't a pathname, its

     * the full XLFD string like :-

     * "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"

     */

     private static Map xlfdMap = new HashMap();

    /*

     * Used to eliminate redundant work. When a font directory is

     * registered it added to this list. Subsequent registrations for the

     * same directory can then be skipped by checking this Map.

     * Access to this map is not synchronised here since creation

     * of the singleton GE instance is already synchronised and that is

     * the only code path that accesses this map.

     */

     private static HashMap registeredDirs = new HashMap();

    /* Array of directories to be added to the X11 font path.

     * Used by static method called from Toolkits which use X11 fonts.

     * Specifically this means MToolkit

     */

    private static String[] fontdirs = null;

    static {

        java.security.AccessController.doPrivileged(

                          new java.security.PrivilegedAction() {

            public Object run() {

                System.loadLibrary("awt");

                /*

                 * Note: The MToolkit object depends on the static initializer

                 * of X11GraphicsEnvironment to initialize the connection to

                 * the X11 server.

                 */

                if (!isHeadless()) {

                    // first check the OGL system property

                    boolean glxRequested = false;

                    String prop = System.getProperty("sun.java2d.opengl");

                    if (prop != null) {

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

                            glxRequested = true;

                        } else if (prop.equals("True") || prop.equals("T")) {

                            glxRequested = true;

                            glxVerbose = true;

                        }

                    }

                    // initialize the X11 display connection

                    initDisplay(glxRequested);

                    // only attempt to initialize GLX if it was requested

                    if (glxRequested) {

                        glxAvailable = initGLX();

                        if (glxVerbose && !glxAvailable) {

                            System.out.println(

                                "Could not enable OpenGL " +

                                "pipeline (GLX 1.3 not available)");

                        }

                    }

                }

                return null;

            }

         });

    }

    private static boolean glxAvailable;

    private static boolean glxVerbose;

    private static native boolean initGLX();

    public static boolean isGLXAvailable() {

        return glxAvailable;

    }

    public static boolean isGLXVerbose() {

        return glxVerbose;

    }

    /**

     * Checks if Shared Memory extension can be used.

     * Returns:

     *   -1 if server doesn't support MITShm

     *    1 if server supports it and it can be used

     *    0 otherwise

     */

    private static native int checkShmExt();

    private static  native String getDisplayString();

    private static Boolean isDisplayLocal;

    /**

     * This should only be called from the static initializer, so no need for

     * the synchronized keyword.

     */

    private static native void initDisplay(boolean glxRequested);

    public X11GraphicsEnvironment() {

    }

    protected native int getNumScreens();

    protected GraphicsDevice makeScreenDevice(int screennum) {

        return new X11GraphicsDevice(screennum);

    }

    protected native int getDefaultScreenNum();

    /**

     * Returns the default screen graphics device.

     */

    public GraphicsDevice getDefaultScreenDevice() {

        return getScreenDevices()[getDefaultScreenNum()];

    }

    public static boolean isDisplayLocal() {

        if (isDisplayLocal == null) {

            SunToolkit.awtLock();

            try {

                if (isDisplayLocal == null) {

                    isDisplayLocal = Boolean.valueOf(_isDisplayLocal());

                }

            } finally {

                SunToolkit.awtUnlock();

            }

        }

        return isDisplayLocal.booleanValue();

    }

    private static boolean _isDisplayLocal() {

        if (isHeadless()) {

            return true;

        }

        String isRemote = (String)java.security.AccessController.doPrivileged(

            new sun.security.action.GetPropertyAction("sun.java2d.remote"));

        if (isRemote != null) {

            return isRemote.equals("false");

        }

        int shm = checkShmExt();

        if (shm != -1) {

            return (shm == 1);

        }

        // If XServer doesn't support ShMem extension,

        // try the other way

        String display = getDisplayString();

        int ind = display.indexOf(':');

        final String hostName = display.substring(0, ind);

        if (ind <= 0) {

            // ':0' case

            return true;

        }

        Boolean result = (Boolean)java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction() {

            public Object run() {

                InetAddress remAddr[] = null;

                Enumeration locals = null;

                Enumeration interfaces = null;

                try {

                    interfaces = NetworkInterface.getNetworkInterfaces();

                    remAddr = InetAddress.getAllByName(hostName);

                    if (remAddr == null) {

                        return Boolean.FALSE;

                    }

                } catch (UnknownHostException e) {

                    System.err.println("Unknown host: " + hostName);

                    return Boolean.FALSE;

                } catch (SocketException e1) {

                    System.err.println(e1.getMessage());

                    return Boolean.FALSE;

                }

                for (; interfaces.hasMoreElements();) {

                    locals = ((NetworkInterface)interfaces.nextElement()).getInetAddresses();

                    for (; locals.hasMoreElements();) {

                        for (int i = 0; i < remAddr.length; i++) {

                            if (locals.nextElement().equals(remAddr[i])) {

                                return Boolean.TRUE;

                            }

                        }

                    }

                }

                return Boolean.FALSE;

            }});

        return result.booleanValue();

    }

    /* These maps are used on Linux where we reference the Lucida oblique

     * fonts in fontconfig files even though they aren't in the standard

     * font directory. This explicitly remaps the XLFDs for these to the

     * correct base font. This is needed to prevent composite fonts from

     * defaulting to the Lucida Sans which is a bad substitute for the

     * monospaced Lucida Sans Typewriter. Also these maps prevent the

     * JRE from doing wasted work at start up.

     */

    HashMap<String, String> oblmap = null;

    private String getObliqueLucidaFontID(String fontID) {

        if (fontID.startsWith("-lucidasans-medium-i-normal") ||

            fontID.startsWith("-lucidasans-bold-i-normal") ||

            fontID.startsWith("-lucidatypewriter-medium-i-normal") ||

            fontID.startsWith("-lucidatypewriter-bold-i-normal")) {

            return fontID.substring(0, fontID.indexOf("-i-"));

        } else {

            return null;

        }

    }

   private void initObliqueLucidaFontMap() {

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

       oblmap.put("-lucidasans-medium",

                  jreLibDirName+"/fonts/LucidaSansRegular.ttf");

       oblmap.put("-lucidasans-bold",

                  jreLibDirName+"/fonts/LucidaSansDemiBold.ttf");

       oblmap.put("-lucidatypewriter-medium",

                  jreLibDirName+"/fonts/LucidaTypewriterRegular.ttf");

       oblmap.put("-lucidatypewriter-bold",

                  jreLibDirName+"/fonts/LucidaTypewriterBold.ttf");

   }

    /**

     * Takes family name property in the following format:

     * "-linotype-helvetica-medium-r-normal-sans-*-%d-*-*-p-*-iso8859-1"

     * and returns the name of the corresponding physical font.

     * This code is used to resolve font configuration fonts, and expects

     * only to get called for these fonts.

     */

    public String getFileNameFromPlatformName(String platName) {

        String fileName = null;

        String fontID = specificFontIDForName(platName);

        /* If the font filename has been explicitly assigned in the

         * font configuration file, use it. This avoids accessing

         * the wrong fonts on Linux, where different fonts (some

         * of which may not be usable by 2D) may share the same

         * specific font ID. It may also speed up the lookup.

         */

        fileName = super.getFileNameFromPlatformName(platName);

        if (fileName != null) {

            if (isHeadless() && fileName.startsWith("-")) {

                /* if it's headless, no xlfd should be used */

                    return null;

            }

            if (fileName.startsWith("/")) {

                /* If a path is assigned in the font configuration file,

                 * it is required that the config file also specify using the

                 * new awtfontpath key the X11 font directories

                 * which must be added to the X11 font path to support

                 * AWT access to that font. For that reason we no longer

                 * have code here to add the parent directory to the list

                 * of font config dirs, since the parent directory may not

                 * be sufficient if fonts are symbolically linked to a

                 * different directory.

                 *

                 * Add this XLFD (platform name) to the list of known

                 * ones for this file.

                 */

                Vector xVal = (Vector) xlfdMap.get(fileName);

                if (xVal == null) {

                    /* Try to be robust on Linux distros which move fonts

                     * around by verifying that the fileName represents a

                     * file that exists.  If it doesn't, set it to null

                     * to trigger a search.

                     */

                    if (getFontConfiguration().needToSearchForFile(fileName)) {

                        fileName = null;

                    }

                    if (fileName != null) {

                        xVal = new Vector();

                        xVal.add(platName);

                        xlfdMap.put(fileName, xVal);

                    }

                } else {

                    if (!xVal.contains(platName)) {

                        xVal.add(platName);

                    }

                }

            }

            if (fileName != null) {

                fontNameMap.put(fontID, fileName);

                return fileName;

            }

        }

        if (fontID != null) {

            fileName = (String)fontNameMap.get(fontID);

            /* On Linux check for the Lucida Oblique fonts */

            if (fileName == null && isLinux && !isOpenJDK()) {

                if (oblmap == null) {

                    initObliqueLucidaFontMap();

                }

                String oblkey = getObliqueLucidaFontID(fontID);

                if (oblkey != null) {

                    fileName = oblmap.get(oblkey);

                }

            }

            if (fontPath == null &&

                (fileName == null || !fileName.startsWith("/"))) {

                if (debugFonts) {

                    logger.warning("** Registering all font paths because " +

                                   "can't find file for " + platName);

                }

                fontPath = getPlatformFontPath(noType1Font);

                registerFontDirs(fontPath);

                if (debugFonts) {

                    logger.warning("** Finished registering all font paths");

                }

                fileName = (String)fontNameMap.get(fontID);

            }

            if (fileName == null && !isHeadless()) {

                /* Query X11 directly to see if this font is available

                 * as a native font.

                 */

                fileName = getX11FontName(platName);

            }

            if (fileName == null) {

                fontID = switchFontIDForName(platName);

                fileName = (String)fontNameMap.get(fontID);

            }

            if (fileName != null) {

                fontNameMap.put(fontID, fileName);

            }

        }

        return fileName;

    }

    private static String getX11FontName(String platName) {

        String xlfd = platName.replaceAll("%d", "*");

        if (NativeFont.fontExists(xlfd)) {

            return xlfd;

        } else {

            return null;

        }

    }

    /**

     * Returns the face name for the given XLFD.

     */

    public String getFileNameFromXLFD(String name) {

        String fileName = null;

        String fontID = specificFontIDForName(name);

        if (fontID != null) {

            fileName = (String)fontNameMap.get(fontID);

            if (fileName == null) {

                fontID = switchFontIDForName(name);

                fileName = (String)fontNameMap.get(fontID);

            }

            if (fileName == null) {

                fileName = getDefaultFontFile();

            }

        }

        return fileName;

    }

    // constants identifying XLFD and font ID fields

    private static final int FOUNDRY_FIELD = 1;

    private static final int FAMILY_NAME_FIELD = 2;

    private static final int WEIGHT_NAME_FIELD = 3;

    private static final int SLANT_FIELD = 4;

    private static final int SETWIDTH_NAME_FIELD = 5;

    private static final int ADD_STYLE_NAME_FIELD = 6;

    private static final int PIXEL_SIZE_FIELD = 7;

    private static final int POINT_SIZE_FIELD = 8;

    private static final int RESOLUTION_X_FIELD = 9;

    private static final int RESOLUTION_Y_FIELD = 10;

    private static final int SPACING_FIELD = 11;

    private static final int AVERAGE_WIDTH_FIELD = 12;

    private static final int CHARSET_REGISTRY_FIELD = 13;

    private static final int CHARSET_ENCODING_FIELD = 14;

    private String switchFontIDForName(String name) {

        int[] hPos = new int[14];

        int hyphenCnt = 1;

        int pos = 1;

        while (pos != -1 && hyphenCnt < 14) {

            pos = name.indexOf('-', pos);

            if (pos != -1) {

                hPos[hyphenCnt++] = pos;

                    pos++;

            }

        }

        if (hyphenCnt != 14) {

            if (debugFonts) {

                logger.severe("Font Configuration Font ID is malformed:" + name);

            }

            return name; // what else can we do?

        }

        String slant = name.substring(hPos[SLANT_FIELD-1]+1,

                                           hPos[SLANT_FIELD]);

        String family = name.substring(hPos[FAMILY_NAME_FIELD-1]+1,

                                           hPos[FAMILY_NAME_FIELD]);

        String registry = name.substring(hPos[CHARSET_REGISTRY_FIELD-1]+1,

                                           hPos[CHARSET_REGISTRY_FIELD]);

        String encoding = name.substring(hPos[CHARSET_ENCODING_FIELD-1]+1);

        if (slant.equals("i")) {

            slant = "o";

        } else if (slant.equals("o")) {

            slant = "i";

        }