/* * Copyright (c) 1997, 2009, 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. In Sun's implementation *       the location is <code>${java.home}/lib/swing.properties</code>. *       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>Sytem 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 agressively 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<sup><font size="-2">TM</font></sup> * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @author Thomas Ball * @author Hans Muller */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;        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 for the properties file in <java.home>/lib/swing.properties.     * 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 swing.properties 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 filename for swing.properties is a path like this (Unix version):     * <java.home>/lib/swing.properties.  This method returns a bogus     * filename if java.home 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>";        }        return javaHome + sep + "lib" + sep + "swing.properties";    }      /**     * 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> specifiying 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     * swing.properties     * 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 {            // 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

Lines 1–500 of 1463. Load more