/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
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
* <code>swing.properties</code> file is located in the <code>lib</code>
* 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
*/
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.
* It is typically located in the <code>lib</code> subdirectory of the Java
* 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>";
}
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> 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
*/
public static void
setLookAndFeel(
LookAndFeel newLookAndFeel)
throws
UnsupportedLookAndFeelException
{
if ((
newLookAndFeel != null) && !
newLookAndFeel.
isSupportedLookAndFeel()) {
String s =
newLookAndFeel.
toString() + " not supported on this platform";
throw new
UnsupportedLookAndFeelException(
s);
}
LAFState lafState =
getLAFState();
LookAndFeel oldLookAndFeel =
lafState.
lookAndFeel;
if (
oldLookAndFeel != null) {
oldLookAndFeel.
uninitialize();
}
lafState.
lookAndFeel =
newLookAndFeel;
if (
newLookAndFeel != null) {
sun.swing.
DefaultLookup.
setDefaultLookup(null);
newLookAndFeel.
initialize();
lafState.
setLookAndFeelDefaults(
newLookAndFeel.
getDefaults());
}
else {
lafState.
setLookAndFeelDefaults(null);
}
SwingPropertyChangeSupport changeSupport =
lafState.
getPropertyChangeSupport(false);
if (
changeSupport != null) {
changeSupport.
firePropertyChange("lookAndFeel",
oldLookAndFeel,
newLookAndFeel);
}
}
/**
* Loads the {@code LookAndFeel} specified by the given class
* name, using the current thread's context class loader, and
* passes it to {@code setLookAndFeel(LookAndFeel)}.
*
* @param className a string specifying the name of the class that implements
* the look and feel
* @exception ClassNotFoundException if the <code>LookAndFeel</code>
* class could not be found
* @exception InstantiationException if a new instance of the class
* couldn't be created
* @exception IllegalAccessException if the class or initializer isn't accessible
* @exception UnsupportedLookAndFeelException if
* <code>lnf.isSupportedLookAndFeel()</code> is false
* @throws ClassCastException if {@code className} does not identify
* a class that extends {@code LookAndFeel}
*/
public static void
setLookAndFeel(
String className)
throws
ClassNotFoundException,
InstantiationException,
IllegalAccessException,
UnsupportedLookAndFeelException
{
if ("javax.swing.plaf.metal.MetalLookAndFeel".
equals(
className)) {
// Avoid reflection for the common case of metal.
setLookAndFeel(new javax.swing.plaf.metal.
MetalLookAndFeel());
}
else {
Class lnfClass =
SwingUtilities.
loadSystemClass(
className);
setLookAndFeel((
LookAndFeel)(
lnfClass.
newInstance()));
}
}
/**
* Returns the name of the <code>LookAndFeel</code> class that implements
* the native system look and feel if there is one, otherwise
* the name of the default cross platform <code>LookAndFeel</code>
* class. This value can be overriden by setting the
* <code>swing.systemlaf</code> system property.
*
* @return the <code>String</code> of the <code>LookAndFeel</code>
* class
*
* @see #setLookAndFeel
* @see #getCrossPlatformLookAndFeelClassName
*/
public static
String getSystemLookAndFeelClassName() {
String systemLAF =
AccessController.
doPrivileged(
new
GetPropertyAction("swing.systemlaf"));
if (
systemLAF != null) {
return
systemLAF;
}
OSInfo.
OSType osType =
AccessController.
doPrivileged(
OSInfo.
getOSTypeAction());
if (
osType ==
OSInfo.
OSType.
WINDOWS) {
return "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
} else {
String desktop =
AccessController.
doPrivileged(new
GetPropertyAction("sun.desktop"));
Toolkit toolkit =
Toolkit.
getDefaultToolkit();
if ("gnome".
equals(
desktop) &&
toolkit instanceof
SunToolkit &&
((
SunToolkit)
toolkit).
isNativeGTKAvailable()) {
// May be set on Linux and Solaris boxs.
return "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
}
if (
osType ==
OSInfo.
OSType.
MACOSX) {
if (
toolkit.
getClass() .
getName()
.
equals("sun.lwawt.macosx.LWCToolkit")) {
return "com.apple.laf.AquaLookAndFeel";
}
}
if (
osType ==
OSInfo.
OSType.
SOLARIS) {
return "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
}
}
return
getCrossPlatformLookAndFeelClassName();
}
/**
* Returns the name of the <code>LookAndFeel</code> class that implements
* the default cross platform look and feel -- the Java
* Look and Feel (JLF). This value can be overriden by setting the
* <code>swing.crossplatformlaf</code> system property.
*
* @return a string with the JLF implementation-class
* @see #setLookAndFeel
* @see #getSystemLookAndFeelClassName
*/
public static
String getCrossPlatformLookAndFeelClassName() {
String laf =
AccessController.
doPrivileged(
new
GetPropertyAction("swing.crossplatformlaf"));
if (
laf != null) {
return
laf;
}
return "javax.swing.plaf.metal.MetalLookAndFeel";
}
/**
* Returns the defaults. The returned defaults resolve using the
* logic specified in the class documentation.
*
* @return a <code>UIDefaults</code> object containing the default values
*/
public static
UIDefaults getDefaults() {
maybeInitialize();
return
getLAFState().
multiUIDefaults;
}
/**
* Returns a font from the defaults. If the value for {@code key} is
* not a {@code Font}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the font
* @return the <code>Font</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Font getFont(
Object key) {
return
getDefaults().
getFont(
key);
}
/**
* Returns a font from the defaults that is appropriate
* for the given locale. If the value for {@code key} is
* not a {@code Font}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the font
* @param l the <code>Locale</code> for which the font is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Font</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Font getFont(
Object key,
Locale l) {
return
getDefaults().
getFont(
key,
l);
}
/**
* Returns a color from the defaults. If the value for {@code key} is
* not a {@code Color}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the color
* @return the <code>Color</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Color getColor(
Object key) {
return
getDefaults().
getColor(
key);
}
/**
* Returns a color from the defaults that is appropriate
* for the given locale. If the value for {@code key} is
* not a {@code Color}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the color
* @param l the <code>Locale</code> for which the color is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Color</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Color getColor(
Object key,
Locale l) {
return
getDefaults().
getColor(
key,
l);
}
/**
* Returns an <code>Icon</code> from the defaults. If the value for
* {@code key} is not an {@code Icon}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the icon
* @return the <code>Icon</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Icon getIcon(
Object key) {
return
getDefaults().
getIcon(
key);
}
/**
* Returns an <code>Icon</code> from the defaults that is appropriate
* for the given locale. If the value for
* {@code key} is not an {@code Icon}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the icon
* @param l the <code>Locale</code> for which the icon is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Icon</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Icon getIcon(
Object key,
Locale l) {
return
getDefaults().
getIcon(
key,
l);
}
/**
* Returns a border from the defaults. If the value for
* {@code key} is not a {@code Border}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the border
* @return the <code>Border</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Border getBorder(
Object key) {
return
getDefaults().
getBorder(
key);
}
/**
* Returns a border from the defaults that is appropriate
* for the given locale. If the value for
* {@code key} is not a {@code Border}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the border
* @param l the <code>Locale</code> for which the border is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Border</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Border getBorder(
Object key,
Locale l) {
return
getDefaults().
getBorder(
key,
l);
}
/**
* Returns a string from the defaults. If the value for
* {@code key} is not a {@code String}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the string
* @return the <code>String</code>
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
String getString(
Object key) {
return
getDefaults().
getString(
key);
}
/**
* Returns a string from the defaults that is appropriate for the
* given locale. If the value for
* {@code key} is not a {@code String}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the string
* @param l the <code>Locale</code> for which the string is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>String</code>
* @since 1.4
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
String getString(
Object key,
Locale l) {
return
getDefaults().
getString(
key,
l);
}
/**
* Returns a string from the defaults that is appropriate for the
* given locale. If the value for
* {@code key} is not a {@code String}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the string
* @param c {@code Component} used to determine the locale;
* {@code null} implies the default locale as
* returned by {@code Locale.getDefault()}
* @return the <code>String</code>
* @throws NullPointerException if {@code key} is {@code null}
*/
static
String getString(
Object key,
Component c) {
Locale l = (
c == null) ?
Locale.
getDefault() :
c.
getLocale();
return
getString(
key,
l);
}
/**
* Returns an integer from the defaults. If the value for
* {@code key} is not an {@code Integer}, or does not exist,
* {@code 0} is returned.
*
* @param key an <code>Object</code> specifying the int
* @return the int
* @throws NullPointerException if {@code key} is {@code null}
*/
public static int
getInt(
Object key) {
return
getDefaults().
getInt(
key);
}
/**
* Returns an integer from the defaults that is appropriate
* for the given locale. If the value for
* {@code key} is not an {@code Integer}, or does not exist,
* {@code 0} is returned.
*
* @param key an <code>Object</code> specifying the int
* @param l the <code>Locale</code> for which the int is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the int
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static int
getInt(
Object key,
Locale l) {
return
getDefaults().
getInt(
key,
l);
}
/**
* Returns a boolean from the defaults which is associated with
* the key value. If the key is not found or the key doesn't represent
* a boolean value then {@code false} is returned.
*
* @param key an <code>Object</code> specifying the key for the desired boolean value
* @return the boolean value corresponding to the key
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static boolean
getBoolean(
Object key) {
return
getDefaults().
getBoolean(
key);
}
/**
* Returns a boolean from the defaults which is associated with
* the key value and the given <code>Locale</code>. If the key is not
* found or the key doesn't represent
* a boolean value then {@code false} will be returned.
*
* @param key an <code>Object</code> specifying the key for the desired
* boolean value
* @param l the <code>Locale</code> for which the boolean is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the boolean value corresponding to the key
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static boolean
getBoolean(
Object key,
Locale l) {
return
getDefaults().
getBoolean(
key,
l);
}
/**
* Returns an <code>Insets</code> object from the defaults. If the value
* for {@code key} is not an {@code Insets}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the <code>Insets</code> object
* @return the <code>Insets</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Insets getInsets(
Object key) {
return
getDefaults().
getInsets(
key);
}
/**
* Returns an <code>Insets</code> object from the defaults that is
* appropriate for the given locale. If the value
* for {@code key} is not an {@code Insets}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the <code>Insets</code> object
* @param l the <code>Locale</code> for which the object is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Insets</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Insets getInsets(
Object key,
Locale l) {
return
getDefaults().
getInsets(
key,
l);
}
/**
* Returns a dimension from the defaults. If the value
* for {@code key} is not a {@code Dimension}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the dimension object
* @return the <code>Dimension</code> object
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Dimension getDimension(
Object key) {
return
getDefaults().
getDimension(
key);
}
/**
* Returns a dimension from the defaults that is appropriate
* for the given locale. If the value
* for {@code key} is not a {@code Dimension}, {@code null} is returned.
*
* @param key an <code>Object</code> specifying the dimension object
* @param l the <code>Locale</code> for which the object is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Dimension</code> object
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Dimension getDimension(
Object key,
Locale l) {
return
getDefaults().
getDimension(
key,
l);
}
/**
* Returns an object from the defaults.
*
* @param key an <code>Object</code> specifying the desired object
* @return the <code>Object</code>
* @throws NullPointerException if {@code key} is {@code null}
*/
public static
Object get(
Object key) {
return
getDefaults().
get(
key);
}
/**
* Returns an object from the defaults that is appropriate for
* the given locale.
*
* @param key an <code>Object</code> specifying the desired object
* @param l the <code>Locale</code> for which the object is desired; refer
* to {@code UIDefaults} for details on how a {@code null}
* {@code Locale} is handled
* @return the <code>Object</code>
* @throws NullPointerException if {@code key} is {@code null}
* @since 1.4
*/
public static
Object get(
Object key,
Locale l) {
return
getDefaults().
get(
key,
l);
}
/**
* Stores an object in the developer defaults. This is a cover method
* for {@code getDefaults().put(key, value)}. This only effects the
* developer defaults, not the system or look and feel defaults.
*
* @param key an <code>Object</code> specifying the retrieval key
* @param value the <code>Object</code> to store; refer to
* {@code UIDefaults} for details on how {@code null} is
* handled
* @return the <code>Object</code> returned by {@link UIDefaults#put}
* @throws NullPointerException if {@code key} is {@code null}
* @see UIDefaults#put
*/
public static
Object put(
Object key,
Object value) {
return
getDefaults().
put(
key,
value);
}
/**
* Returns the appropriate {@code ComponentUI} implementation for
* {@code target}. Typically, this is a cover for
* {@code getDefaults().getUI(target)}. However, if an auxiliary
* look and feel has been installed, this first invokes
* {@code getUI(target)} on the multiplexing look and feel's
* defaults, and returns that value if it is {@code non-null}.
*
* @param target the <code>JComponent</code> to return the
* {@code ComponentUI} for
* @return the <code>ComponentUI</code> object for {@code target}
* @throws NullPointerException if {@code target} is {@code null}
* @see UIDefaults#getUI
*/
public static
ComponentUI getUI(
JComponent target) {
maybeInitialize();
maybeInitializeFocusPolicy(
target);
ComponentUI ui = null;
LookAndFeel multiLAF =
getLAFState().
multiLookAndFeel;
if (
multiLAF != null) {
// This can return null if the multiplexing look and feel
// doesn't support a particular UI.
ui =
multiLAF.
getDefaults().
getUI(
target);
}
if (
ui == null) {
ui =
getDefaults().
getUI(
target);
}
return
ui;
}
/**
* Returns the {@code UIDefaults} from the current look and feel,
* that were obtained at the time the look and feel was installed.
* <p>
* In general, developers should use the {@code UIDefaults} returned from
* {@code getDefaults()}. As the current look and feel may expect
* certain values to exist, altering the {@code UIDefaults} returned
* from this method could have unexpected results.
*
* @return <code>UIDefaults</code> from the current look and feel
* @see #getDefaults
* @see #setLookAndFeel(LookAndFeel)
* @see LookAndFeel#getDefaults
*/
public static
UIDefaults getLookAndFeelDefaults() {
maybeInitialize();
return
getLAFState().
getLookAndFeelDefaults();
}
/**
* Finds the Multiplexing <code>LookAndFeel</code>.
*/
private static
LookAndFeel getMultiLookAndFeel() {
LookAndFeel multiLookAndFeel =
getLAFState().
multiLookAndFeel;
if (
multiLookAndFeel == null) {
String defaultName = "javax.swing.plaf.multi.MultiLookAndFeel";
String className =
getLAFState().
swingProps.
getProperty(
multiplexingLAFKey,
defaultName);
try {
Class lnfClass =
SwingUtilities.
loadSystemClass(
className);
multiLookAndFeel = (
LookAndFeel)
lnfClass.
newInstance();
} catch (
Exception exc) {
System.
err.
println("UIManager: failed loading " +
className);
}
}
return
multiLookAndFeel;
}
/**
* Adds a <code>LookAndFeel</code> to the list of auxiliary look and feels.
* The auxiliary look and feels tell the multiplexing look and feel what
* other <code>LookAndFeel</code> classes for a component instance are to be used
* in addition to the default <code>LookAndFeel</code> class when creating a
* multiplexing UI. The change will only take effect when a new
* UI class is created or when the default look and feel is changed
* on a component instance.
* <p>Note these are not the same as the installed look and feels.
*
* @param laf the <code>LookAndFeel</code> object
* @see #removeAuxiliaryLookAndFeel
* @see #setLookAndFeel
* @see #getAuxiliaryLookAndFeels
* @see #getInstalledLookAndFeels
*/
static public void
addAuxiliaryLookAndFeel(
LookAndFeel laf) {
maybeInitialize();
if (!
laf.
isSupportedLookAndFeel()) {
// Ideally we would throw an exception here, but it's too late
// for that.
return;
}
Vector<
LookAndFeel>
v =
getLAFState().
auxLookAndFeels;
if (
v == null) {
v = new
Vector<
LookAndFeel>();
}
if (!
v.
contains(
laf)) {
v.
addElement(
laf);
laf.
initialize();
getLAFState().
auxLookAndFeels =
v;
if (
getLAFState().
multiLookAndFeel == null) {
getLAFState().
multiLookAndFeel =
getMultiLookAndFeel();
}
}
}
/**
* Removes a <code>LookAndFeel</code> from the list of auxiliary look and feels.
* The auxiliary look and feels tell the multiplexing look and feel what
* other <code>LookAndFeel</code> classes for a component instance are to be used
* in addition to the default <code>LookAndFeel</code> class when creating a
* multiplexing UI. The change will only take effect when a new
* UI class is created or when the default look and feel is changed
* on a component instance.
* <p>Note these are not the same as the installed look and feels.
* @return true if the <code>LookAndFeel</code> was removed from the list
* @see #removeAuxiliaryLookAndFeel
* @see #getAuxiliaryLookAndFeels
* @see #setLookAndFeel
* @see #getInstalledLookAndFeels
*/
static public boolean
removeAuxiliaryLookAndFeel(
LookAndFeel laf) {
maybeInitialize();
boolean
result;
Vector<
LookAndFeel>
v =
getLAFState().
auxLookAndFeels;
if ((
v == null) || (
v.
size() == 0)) {
return false;
}
result =
v.
removeElement(
laf);
if (
result) {
if (
v.
size() == 0) {
getLAFState().
auxLookAndFeels = null;
getLAFState().
multiLookAndFeel = null;
} else {
getLAFState().
auxLookAndFeels =
v;
}
}
laf.
uninitialize();
return
result;
}
/**
* Returns the list of auxiliary look and feels (can be <code>null</code>).
* The auxiliary look and feels tell the multiplexing look and feel what
* other <code>LookAndFeel</code> classes for a component instance are
* to be used in addition to the default LookAndFeel class when creating a
* multiplexing UI.
* <p>Note these are not the same as the installed look and feels.
*
* @return list of auxiliary <code>LookAndFeel</code>s or <code>null</code>
* @see #addAuxiliaryLookAndFeel
* @see #removeAuxiliaryLookAndFeel
* @see #setLookAndFeel
* @see #getInstalledLookAndFeels
*/
static public
LookAndFeel[]
getAuxiliaryLookAndFeels() {
maybeInitialize();
Vector<
LookAndFeel>
v =
getLAFState().
auxLookAndFeels;
if ((
v == null) || (
v.
size() == 0)) {
return null;
}
else {
LookAndFeel[]
rv = new
LookAndFeel[
v.
size()];
for (int
i = 0;
i <
rv.length;
i++) {
rv[
i] =
v.
elementAt(
i);
}
return
rv;
}
}
/**
* Adds a <code>PropertyChangeListener</code> to the listener list.
* The listener is registered for all properties.
*
* @param listener the <code>PropertyChangeListener</code> to be added
* @see java.beans.PropertyChangeSupport
*/
public static void
addPropertyChangeListener(
PropertyChangeListener listener)
{
synchronized (
classLock) {
getLAFState().
getPropertyChangeSupport(true).
addPropertyChangeListener(
listener);
}
}
/**
* Removes a <code>PropertyChangeListener</code> from the listener list.
* This removes a <code>PropertyChangeListener</code> that was registered
* for all properties.
*
* @param listener the <code>PropertyChangeListener</code> to be removed
* @see java.beans.PropertyChangeSupport
*/
public static void
removePropertyChangeListener(
PropertyChangeListener listener)
{
synchronized (
classLock) {
getLAFState().
getPropertyChangeSupport(true).
removePropertyChangeListener(
listener);
}
}
/**
* Returns an array of all the <code>PropertyChangeListener</code>s added
* to this UIManager with addPropertyChangeListener().
*
* @return all of the <code>PropertyChangeListener</code>s added or an empty
* array if no listeners have been added
* @since 1.4
*/
public static
PropertyChangeListener[]
getPropertyChangeListeners() {
synchronized(
classLock) {
return
getLAFState().
getPropertyChangeSupport(true).
getPropertyChangeListeners();
}
}
private static
Properties loadSwingProperties()
{
/* Don't bother checking for Swing properties if untrusted, as
* there's no way to look them up without triggering SecurityExceptions.
*/
if (
UIManager.class.
getClassLoader() != null) {
return new
Properties();
}
else {
final
Properties props = new
Properties();
java.security.
AccessController.
doPrivileged(
new java.security.
PrivilegedAction<
Object>() {
public
Object run() {
OSInfo.
OSType osType =
AccessController.
doPrivileged(
OSInfo.
getOSTypeAction());
if (
osType ==
OSInfo.
OSType.
MACOSX) {
props.
put(
defaultLAFKey,
getSystemLookAndFeelClassName());
}
try {
File file = new
File(
makeSwingPropertiesFilename());
if (
file.
exists()) {
// InputStream has been buffered in Properties
// class
FileInputStream ins = new
FileInputStream(
file);
props.
load(
ins);
ins.
close();
}
}
catch (
Exception e) {
// No such file, or file is otherwise non-readable.
}
// Check whether any properties were overridden at the
// command line.
checkProperty(
props,
defaultLAFKey);
checkProperty(
props,
auxiliaryLAFsKey);
checkProperty(
props,
multiplexingLAFKey);
checkProperty(
props,
installedLAFsKey);
checkProperty(
props,
disableMnemonicKey);
// Don't care about return value.
return null;
}
});
return
props;
}
}
private static void
checkProperty(
Properties props,
String key) {
// No need to do catch the SecurityException here, this runs
// in a doPrivileged.
String value =
System.
getProperty(
key);
if (
value != null) {
props.
put(
key,
value);
}
}
/**
* If a <code>swing.properties</code> file exist and it has a
* <code>swing.installedlafs</code> property
* then initialize the <code>installedLAFs</code> field.
*
* @see #getInstalledLookAndFeels
*/
private static void
initializeInstalledLAFs(
Properties swingProps)
{
String ilafsString =
swingProps.
getProperty(
installedLAFsKey);
if (
ilafsString == null) {
return;
}
/* Create a vector that contains the value of the swing.installedlafs
* property. For example given "swing.installedlafs=motif,windows"
* lafs = {"motif", "windows"}.
*/
Vector<
String>
lafs = new
Vector<
String>();
StringTokenizer st = new
StringTokenizer(
ilafsString, ",", false);
while (
st.
hasMoreTokens()) {
lafs.
addElement(
st.
nextToken());
}
/* Look up the name and class for each name in the "swing.installedlafs"
* list. If they both exist then add a LookAndFeelInfo to
* the installedLafs array.
*/
Vector<
LookAndFeelInfo>
ilafs = new
Vector<
LookAndFeelInfo>(
lafs.
size());
for (
String laf :
lafs) {
String name =
swingProps.
getProperty(
makeInstalledLAFKey(
laf, "name"),
laf);
String cls =
swingProps.
getProperty(
makeInstalledLAFKey(
laf, "class"));
if (
cls != null) {
ilafs.
addElement(new
LookAndFeelInfo(
name,
cls));
}
}
LookAndFeelInfo[]
installedLAFs = new
LookAndFeelInfo[
ilafs.
size()];
for(int
i = 0;
i <
ilafs.
size();
i++) {
installedLAFs[
i] =
ilafs.
elementAt(
i);
}
getLAFState().
installedLAFs =
installedLAFs;
}
/**
* If the user has specified a default look and feel, use that.
* Otherwise use the look and feel that's native to this platform.
* If this code is called after the application has explicitly
* set it's look and feel, do nothing.
*
* @see #maybeInitialize
*/
private static void
initializeDefaultLAF(
Properties swingProps)
{
if (
getLAFState().
lookAndFeel != null) {
return;
}
// Try to get default LAF from system property, then from AppContext
// (6653395), then use cross-platform one by default.
String lafName = null;
HashMap lafData =
(
HashMap)
AppContext.
getAppContext().
remove("swing.lafdata");
if (
lafData != null) {
lafName = (
String)
lafData.
remove("defaultlaf");
}
if (
lafName == null) {
lafName =
getCrossPlatformLookAndFeelClassName();
}
lafName =
swingProps.
getProperty(
defaultLAFKey,
lafName);
try {
setLookAndFeel(
lafName);
} catch (
Exception e) {
throw new
Error("Cannot load " +
lafName);
}
// Set any properties passed through AppContext (6653395).
if (
lafData != null) {
for (
Object key:
lafData.
keySet()) {
UIManager.
put(
key,
lafData.
get(
key));
}
}
}
private static void
initializeAuxiliaryLAFs(
Properties swingProps)
{
String auxLookAndFeelNames =
swingProps.
getProperty(
auxiliaryLAFsKey);
if (
auxLookAndFeelNames == null) {
return;
}
Vector<
LookAndFeel>
auxLookAndFeels = new
Vector<
LookAndFeel>();
StringTokenizer p = new
StringTokenizer(
auxLookAndFeelNames,",");
String factoryName;
/* Try to load each LookAndFeel subclass in the list.
*/
while (
p.
hasMoreTokens()) {
String className =
p.
nextToken();
try {
Class lnfClass =
SwingUtilities.
loadSystemClass(
className);
LookAndFeel newLAF = (
LookAndFeel)
lnfClass.
newInstance();
newLAF.
initialize();
auxLookAndFeels.
addElement(
newLAF);
}
catch (
Exception e) {
System.
err.
println("UIManager: failed loading auxiliary look and feel " +
className);
}
}
/* If there were problems and no auxiliary look and feels were
* loaded, make sure we reset auxLookAndFeels to null.
* Otherwise, we are going to use the MultiLookAndFeel to get
* all component UI's, so we need to load it now.
*/
if (
auxLookAndFeels.
size() == 0) {
auxLookAndFeels = null;
}
else {
getLAFState().
multiLookAndFeel =
getMultiLookAndFeel();
if (
getLAFState().
multiLookAndFeel == null) {
auxLookAndFeels = null;
}
}
getLAFState().
auxLookAndFeels =
auxLookAndFeels;
}
private static void
initializeSystemDefaults(
Properties swingProps) {
getLAFState().
swingProps =
swingProps;
}
/*
* This method is called before any code that depends on the
* <code>AppContext</code> specific LAFState object runs. When the AppContext
* corresponds to a set of applets it's possible for this method
* to be re-entered, which is why we grab a lock before calling
* initialize().
*/
private static void
maybeInitialize() {
synchronized (
classLock) {
if (!
getLAFState().
initialized) {
getLAFState().
initialized = true;
initialize();
}
}
}
/*
* Sets default swing focus traversal policy.
*/
private static void
maybeInitializeFocusPolicy(
JComponent comp) {
// Check for JRootPane which indicates that a swing toplevel
// is coming, in which case a swing default focus policy
// should be instatiated. See 7125044.
if (
comp instanceof
JRootPane) {
synchronized (
classLock) {
if (!
getLAFState().
focusPolicyInitialized) {
getLAFState().
focusPolicyInitialized = true;
if (
FocusManager.
isFocusManagerEnabled()) {
KeyboardFocusManager.
getCurrentKeyboardFocusManager().
setDefaultFocusTraversalPolicy(
new
LayoutFocusTraversalPolicy());
}
}
}
}
}
/*
* Only called by maybeInitialize().
*/
private static void
initialize() {
Properties swingProps =
loadSwingProperties();
initializeSystemDefaults(
swingProps);
initializeDefaultLAF(
swingProps);
initializeAuxiliaryLAFs(
swingProps);
initializeInstalledLAFs(
swingProps);
// Install Swing's PaintEventDispatcher
if (
RepaintManager.
HANDLE_TOP_LEVEL_PAINT) {
sun.awt.
PaintEventDispatcher.
setPaintEventDispatcher(
new
SwingPaintEventDispatcher());
}
// Install a hook that will be invoked if no one consumes the
// KeyEvent. If the source isn't a JComponent this will process
// key bindings, if the source is a JComponent it implies that
// processKeyEvent was already invoked and thus no need to process
// the bindings again, unless the Component is disabled, in which
// case KeyEvents will no longer be dispatched to it so that we
// handle it here.
KeyboardFocusManager.
getCurrentKeyboardFocusManager().
addKeyEventPostProcessor(new
KeyEventPostProcessor() {
public boolean
postProcessKeyEvent(
KeyEvent e) {
Component c =
e.
getComponent();
if ((!(
c instanceof
JComponent) ||
(
c != null && !
c.
isEnabled())) &&
JComponent.
KeyboardState.
shouldProcess(
e) &&
SwingUtilities.
processKeyBindings(
e)) {
e.
consume();
return true;
}
return false;
}
});
AWTAccessor.
getComponentAccessor().
setRequestFocusController(
JComponent.
focusController);
}
}