/*

 * Copyright (c) 1997, 2014, 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 javax.swing;

import java.awt.Component;

import java.awt.Font;

import java.awt.Color;

import java.awt.Insets;

import java.awt.Dimension;

import java.awt.KeyboardFocusManager;

import java.awt.KeyEventPostProcessor;

import java.awt.Toolkit;

import java.awt.event.KeyEvent;

import java.security.AccessController;

import javax.swing.plaf.ComponentUI;

import javax.swing.border.Border;

import javax.swing.event.SwingPropertyChangeSupport;

import java.beans.PropertyChangeListener;

import java.io.Serializable;

import java.io.File;

import java.io.FileInputStream;

import java.util.ArrayList;

import java.util.Properties;

import java.util.StringTokenizer;

import java.util.Vector;

import java.util.Locale;

import sun.awt.SunToolkit;

import sun.awt.OSInfo;

import sun.security.action.GetPropertyAction;

import sun.swing.SwingUtilities2;

import java.lang.reflect.Method;

import java.util.HashMap;

import sun.awt.AppContext;

import sun.awt.AWTAccessor;

/**

 * {@code UIManager} manages the current look and feel, the set of

 * available look and feels, {@code PropertyChangeListeners} that

 * are notified when the look and feel changes, look and feel defaults, and

 * convenience methods for obtaining various default values.

 *

 * <h3>Specifying the look and feel</h3>

 *

 * The look and feel can be specified in two distinct ways: by

 * specifying the fully qualified name of the class for the look and

 * feel, or by creating an instance of {@code LookAndFeel} and passing

 * it to {@code setLookAndFeel}. The following example illustrates

 * setting the look and feel to the system look and feel:

 * <pre>

 *   UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

 * </pre>

 * The following example illustrates setting the look and feel based on

 * class name:

 * <pre>

 *   UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");

 * </pre>

 * Once the look and feel has been changed it is imperative to invoke

 * {@code updateUI} on all {@code JComponents}. The method {@link

 * SwingUtilities#updateComponentTreeUI} makes it easy to apply {@code

 * updateUI} to a containment hierarchy. Refer to it for

 * details. The exact behavior of not invoking {@code

 * updateUI} after changing the look and feel is

 * unspecified. It is very possible to receive unexpected exceptions,

 * painting problems, or worse.

 *

 * <h3>Default look and feel</h3>

 *

 * The class used for the default look and feel is chosen in the following

 * manner:

 * <ol>

 *   <li>If the system property <code>swing.defaultlaf</code> is

 *       {@code non-null}, use its value as the default look and feel class

 *       name.

 *   <li>If the {@link java.util.Properties} file <code>swing.properties</code>

 *       exists and contains the key <code>swing.defaultlaf</code>,

 *       use its value as the default look and feel class name. The location

 *       that is checked for <code>swing.properties</code> may vary depending

 *       upon the implementation of the Java platform. Typically the

 *       subdirectory of the Java installation directory.

 *       Refer to the release notes of the implementation being used for

 *       further details.

 *   <li>Otherwise use the cross platform look and feel.

 * </ol>

 *

 * <h3>Defaults</h3>

 *

 * {@code UIManager} manages three sets of {@code UIDefaults}. In order, they

 * are:

 * <ol>

 *   <li>Developer defaults. With few exceptions Swing does not

 *       alter the developer defaults; these are intended to be modified

 *       and used by the developer.

 *   <li>Look and feel defaults. The look and feel defaults are

 *       supplied by the look and feel at the time it is installed as the

 *       current look and feel ({@code setLookAndFeel()} is invoked). The

 *       look and feel defaults can be obtained using the {@code

 *       getLookAndFeelDefaults()} method.

 *   <li>System defaults. The system defaults are provided by Swing.

 * </ol>

 * Invoking any of the various {@code get} methods

 * results in checking each of the defaults, in order, returning

 * the first {@code non-null} value. For example, invoking

 * {@code UIManager.getString("Table.foreground")} results in first

 * checking developer defaults. If the developer defaults contain

 * a value for {@code "Table.foreground"} it is returned, otherwise

 * the look and feel defaults are checked, followed by the system defaults.

 * <p>

 * It's important to note that {@code getDefaults} returns a custom

 * instance of {@code UIDefaults} with this resolution logic built into it.

 * For example, {@code UIManager.getDefaults().getString("Table.foreground")}

 * is equivalent to {@code UIManager.getString("Table.foreground")}. Both

 * resolve using the algorithm just described. In many places the

 * documentation uses the word defaults to refer to the custom instance

 * of {@code UIDefaults} with the resolution logic as previously described.

 * <p>

 * When the look and feel is changed, {@code UIManager} alters only the

 * look and feel defaults; the developer and system defaults are not

 * altered by the {@code UIManager} in any way.

 * <p>

 * The set of defaults a particular look and feel supports is defined

 * and documented by that look and feel. In addition, each look and

 * feel, or {@code ComponentUI} provided by a look and feel, may

 * access the defaults at different times in their life cycle. Some

 * look and feels may aggressively look up defaults, so that changing a

 * default may not have an effect after installing the look and feel.

 * Other look and feels may lazily access defaults so that a change to

 * the defaults may effect an existing look and feel. Finally, other look

 * and feels might not configure themselves from the defaults table in

 * any way. None-the-less it is usually the case that a look and feel

 * expects certain defaults, so that in general

 * a {@code ComponentUI} provided by one look and feel will not

 * work with another look and feel.

 * <p>

 * <strong>Warning:</strong>

 * Serialized objects of this class will not be compatible with

 * future Swing releases. The current serialization support is

 * appropriate for short term storage or RMI between applications running

 * the same version of Swing.  As of 1.4, support for long term storage

 * of all JavaBeans™

 * has been added to the <code>java.beans</code> package.

 * Please see {@link java.beans.XMLEncoder}.

 *

 * @author Thomas Ball

 * @author Hans Muller

 * @since 1.2

 */

@SuppressWarnings("serial") // Same-version serialization only

public class UIManager implements Serializable

{

    /**

     * This class defines the state managed by the <code>UIManager</code>.  For

     * Swing applications the fields in this class could just as well

     * be static members of <code>UIManager</code> however we give them

     * "AppContext"

     * scope instead so that applets (and potentially multiple lightweight

     * applications running in a single VM) have their own state. For example,

     * an applet can alter its look and feel, see <code>setLookAndFeel</code>.

     * Doing so has no affect on other applets (or the browser).

     */

    private static class LAFState

    {

        Properties swingProps;

        private UIDefaults[] tables = new UIDefaults[2];

        boolean initialized = false;

        boolean focusPolicyInitialized = false;

        MultiUIDefaults multiUIDefaults = new MultiUIDefaults(tables);

        LookAndFeel lookAndFeel;

        LookAndFeel multiLookAndFeel = null;

        Vector<LookAndFeel> auxLookAndFeels = null;

        SwingPropertyChangeSupport changeSupport;

        LookAndFeelInfo[] installedLAFs;

        UIDefaults getLookAndFeelDefaults() { return tables[0]; }

        void setLookAndFeelDefaults(UIDefaults x) { tables[0] = x; }

        UIDefaults getSystemDefaults() { return tables[1]; }

        void setSystemDefaults(UIDefaults x) { tables[1] = x; }

        /**

         * Returns the SwingPropertyChangeSupport for the current

         * AppContext.  If <code>create</code> is a true, a non-null

         * <code>SwingPropertyChangeSupport</code> will be returned, if

         * <code>create</code> is false and this has not been invoked

         * with true, null will be returned.

         */

        public synchronized SwingPropertyChangeSupport

                                 getPropertyChangeSupport(boolean create) {

            if (create && changeSupport == null) {

                changeSupport = new SwingPropertyChangeSupport(

                                         UIManager.class);

            }

            return changeSupport;

        }

    }

    /* Lock object used in place of class object for synchronization. (4187686)

     */

    private static final Object classLock = new Object();

    /**

     * Return the <code>LAFState</code> object, lazily create one if necessary.

     * All access to the <code>LAFState</code> fields is done via this method,

     * for example:

     * <pre>

     *     getLAFState().initialized = true;

     * </pre>

     */

    private static LAFState getLAFState() {

        LAFState rv = (LAFState)SwingUtilities.appContextGet(

                SwingUtilities2.LAF_STATE_KEY);

        if (rv == null) {

            synchronized (classLock) {

                rv = (LAFState)SwingUtilities.appContextGet(

                        SwingUtilities2.LAF_STATE_KEY);

                if (rv == null) {

                    SwingUtilities.appContextPut(

                            SwingUtilities2.LAF_STATE_KEY,

                            (rv = new LAFState()));

                }

            }

        }

        return rv;

    }

    /* Keys used in the <code>swing.properties</code> properties file.

     * See loadUserProperties(), initialize().

     */

    private static final String defaultLAFKey = "swing.defaultlaf";

    private static final String auxiliaryLAFsKey = "swing.auxiliarylaf";

    private static final String multiplexingLAFKey = "swing.plaf.multiplexinglaf";

    private static final String installedLAFsKey = "swing.installedlafs";

    private static final String disableMnemonicKey = "swing.disablenavaids";

    /**

     * Return a <code>swing.properties</code> file key for the attribute of specified

     * look and feel.  The attr is either "name" or "class", a typical

     * key would be: "swing.installedlaf.windows.name"

     */

    private static String makeInstalledLAFKey(String laf, String attr) {

        return "swing.installedlaf." + laf + "." + attr;

    }

    /**

     * The location of the <code>swing.properties</code> property file is

     * implementation-specific.

     * installation directory. This method returns a bogus filename

     * if <code>java.home</code> isn't defined.

     */

    private static String makeSwingPropertiesFilename() {

        String sep = File.separator;

        // No need to wrap this in a doPrivileged as it's called from

        // a doPrivileged.

        String javaHome = System.getProperty("java.home");

        if (javaHome == null) {

            javaHome = "<java.home undefined>";

        }

    }

    /**

     * Provides a little information about an installed

     * <code>LookAndFeel</code> for the sake of configuring a menu or

     * for initial application set up.

     *

     * @see UIManager#getInstalledLookAndFeels

     * @see LookAndFeel

     */

    public static class LookAndFeelInfo {

        private String name;

        private String className;

        /**

         * Constructs a <code>UIManager</code>s

         * <code>LookAndFeelInfo</code> object.

         *

         * @param name      a <code>String</code> specifying the name of

         *                      the look and feel

         * @param className a <code>String</code> specifying the name of

         *                      the class that implements the look and feel

         */

        public LookAndFeelInfo(String name, String className) {

            this.name = name;

            this.className = className;

        }

        /**

         * Returns the name of the look and feel in a form suitable

         * for a menu or other presentation

         * @return a <code>String</code> containing the name

         * @see LookAndFeel#getName

         */

        public String getName() {

            return name;

        }

        /**

         * Returns the name of the class that implements this look and feel.

         * @return the name of the class that implements this

         *              <code>LookAndFeel</code>

         * @see LookAndFeel

         */

        public String getClassName() {

            return className;

        }

        /**

         * Returns a string that displays and identifies this

         * object's properties.

         *

         * @return a <code>String</code> representation of this object

         */

        public String toString() {

            return getClass().getName() + "[" + getName() + " " + getClassName() + "]";

        }

    }

    /**

     * The default value of <code>installedLAFS</code> is used when no

     * <code>swing.properties</code>

     * file is available or if the file doesn't contain a "swing.installedlafs"

     * property.

     *

     * @see #initializeInstalledLAFs

     */

    private static LookAndFeelInfo[] installedLAFs;

    static {

        ArrayList<LookAndFeelInfo> iLAFs = new ArrayList<LookAndFeelInfo>(4);

        iLAFs.add(new LookAndFeelInfo(

                      "Metal", "javax.swing.plaf.metal.MetalLookAndFeel"));

        iLAFs.add(new LookAndFeelInfo(

                      "Nimbus", "javax.swing.plaf.nimbus.NimbusLookAndFeel"));

        iLAFs.add(new LookAndFeelInfo("CDE/Motif",

                  "com.sun.java.swing.plaf.motif.MotifLookAndFeel"));

        // Only include windows on Windows boxs.

        OSInfo.OSType osType = AccessController.doPrivileged(OSInfo.getOSTypeAction());

        if (osType == OSInfo.OSType.WINDOWS) {

            iLAFs.add(new LookAndFeelInfo("Windows",

                        "com.sun.java.swing.plaf.windows.WindowsLookAndFeel"));

            if (Toolkit.getDefaultToolkit().getDesktopProperty(

                    "win.xpstyle.themeActive") != null) {

                iLAFs.add(new LookAndFeelInfo("Windows Classic",

                 "com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel"));

            }

        }

        else if (osType == OSInfo.OSType.MACOSX) {

            iLAFs.add(new LookAndFeelInfo("Mac OS X", "com.apple.laf.AquaLookAndFeel"));

        }

        else {

            // GTK is not shipped on Windows.

            iLAFs.add(new LookAndFeelInfo("GTK+",

                  "com.sun.java.swing.plaf.gtk.GTKLookAndFeel"));

        }

        installedLAFs = iLAFs.toArray(new LookAndFeelInfo[iLAFs.size()]);

    }

    /**

     * Returns an array of {@code LookAndFeelInfo}s representing the

     * {@code LookAndFeel} implementations currently available. The

     * <code>LookAndFeelInfo</code> objects can be used by an

     * application to construct a menu of look and feel options for

     * the user, or to determine which look and feel to set at startup

     * time. To avoid the penalty of creating numerous {@code

     * LookAndFeel} objects, {@code LookAndFeelInfo} maintains the

     * class name of the {@code LookAndFeel} class, not the actual

     * {@code LookAndFeel} instance.

     * <p>

     * The following example illustrates setting the current look and feel

     * from an instance of {@code LookAndFeelInfo}:

     * <pre>

     *   UIManager.setLookAndFeel(info.getClassName());

     * </pre>

     *

     * @return an array of <code>LookAndFeelInfo</code> objects

     * @see #setLookAndFeel

     */

    public static LookAndFeelInfo[] getInstalledLookAndFeels() {

        maybeInitialize();

        LookAndFeelInfo[] ilafs = getLAFState().installedLAFs;

        if (ilafs == null) {

            ilafs = installedLAFs;

        }

        LookAndFeelInfo[] rv = new LookAndFeelInfo[ilafs.length];

        System.arraycopy(ilafs, 0, rv, 0, ilafs.length);

        return rv;

    }

    /**

     * Sets the set of available look and feels. While this method does

     * not check to ensure all of the {@code LookAndFeelInfos} are

     * {@code non-null}, it is strongly recommended that only {@code non-null}

     * values are supplied in the {@code infos} array.

     *

     * @param infos set of <code>LookAndFeelInfo</code> objects specifying

     *        the available look and feels

     *

     * @see #getInstalledLookAndFeels

     * @throws NullPointerException if {@code infos} is {@code null}

     */

    public static void setInstalledLookAndFeels(LookAndFeelInfo[] infos)

        throws SecurityException

    {

        maybeInitialize();

        LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length];

        System.arraycopy(infos, 0, newInfos, 0, infos.length);

        getLAFState().installedLAFs = newInfos;

    }

    /**

     * Adds the specified look and feel to the set of available look

     * and feels. While this method allows a {@code null} {@code info},

     * it is strongly recommended that a {@code non-null} value be used.

     *

     * @param info a <code>LookAndFeelInfo</code> object that names the

     *          look and feel and identifies the class that implements it

     * @see #setInstalledLookAndFeels

     */

    public static void installLookAndFeel(LookAndFeelInfo info) {

        LookAndFeelInfo[] infos = getInstalledLookAndFeels();

        LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length + 1];

        System.arraycopy(infos, 0, newInfos, 0, infos.length);

        newInfos[infos.length] = info;

        setInstalledLookAndFeels(newInfos);

    }

    /**

     * Adds the specified look and feel to the set of available look

     * and feels. While this method does not check the

     * arguments in any way, it is strongly recommended that {@code

     * non-null} values be supplied.

     *

     * @param name descriptive name of the look and feel

     * @param className name of the class that implements the look and feel

     * @see #setInstalledLookAndFeels

     */

    public static void installLookAndFeel(String name, String className) {

        installLookAndFeel(new LookAndFeelInfo(name, className));

    }

    /**

     * Returns the current look and feel or <code>null</code>.

     *

     * @return current look and feel, or <code>null</code>

     * @see #setLookAndFeel

     */

    public static LookAndFeel getLookAndFeel() {

        maybeInitialize();

        return getLAFState().lookAndFeel;

    }

    /**

     * Sets the current look and feel to {@code newLookAndFeel}.

     * If the current look and feel is {@code non-null} {@code

     * uninitialize} is invoked on it. If {@code newLookAndFeel} is

     * {@code non-null}, {@code initialize} is invoked on it followed

     * by {@code getDefaults}. The defaults returned from {@code

     * newLookAndFeel.getDefaults()} replace those of the defaults

     * from the previous look and feel. If the {@code newLookAndFeel} is

     * {@code null}, the look and feel defaults are set to {@code null}.

     * <p>

     * A value of {@code null} can be used to set the look and feel

     * to {@code null}. As the {@code LookAndFeel} is required for

     * most of Swing to function, setting the {@code LookAndFeel} to

     * {@code null} is strongly discouraged.

     * <p>

     * This is a JavaBeans bound property.

     *

     * @param newLookAndFeel {@code LookAndFeel} to install

     * @throws UnsupportedLookAndFeelException if

     *          {@code newLookAndFeel} is {@code non-null} and

     *          {@code newLookAndFeel.isSupportedLookAndFeel()} returns

     *          {@code false}

     * @see #getLookAndFeel

     */