/* * @(#)UIManager.java 1.115 03/12/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.swing; import java.awt.Component; import java.awt.Container; import java.awt.Window; 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.beans.PropertyChangeEvent; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.io.Serializable; import java.io.File; import java.io.FileInputStream; import java.io.BufferedInputStream; import java.util.ArrayList; import java.util.Enumeration; import java.util.Hashtable; import java.util.Properties; import java.util.StringTokenizer; import java.util.Vector; import java.util.Locale; import sun.security.action.GetPropertyAction; /** * This class keeps track of the current look and feel and its * defaults. * The default look and feel class is chosen in the following manner: *
swing.defaultlaf
is
* non-null, use it as the default look and feel class name.
* swing.properties
* exists and contains the key swing.defaultlaf
,
* use its value as default look and feel class name. The location of
* swing.properties
may vary depending upon the
* implementation of the Java platform. In Sun's implementation
* this will reside in
* &java.home>/lib/swing.properties
. Refer to
* the release notes of the implementation you are using for
* further details.
*
* We manage three levels of defaults: user defaults, look
* and feel defaults, system defaults. A call to UIManager.get
* checks all three levels in order and returns the first non-null
* value for a key, if any. A call to UIManager.put
just
* affects the user defaults. Note that a call to
* setLookAndFeel
doesn't affect the user defaults, it just
* replaces the middle defaults "level".
*
* Warning:
* 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 JavaBeansTM
* has been added to the java.beans
package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see javax.swing.plaf.metal
*
* @version 1.115 12/19/03
* @author Thomas Ball
* @author Hans Muller
*/
public class UIManager implements Serializable
{
/**
* This class defines the state managed by the UIManager
. For
* Swing applications the fields in this class could just as well
* be static members of UIManager
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 setLookAndFeel
.
* 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 auxLookAndFeels = null;
SwingPropertyChangeSupport changeSupport;
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 create
is a true, a non-null
* SwingPropertyChangeSupport
will be returned, if
* create
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;
}
}
/**
* The AppContext
key for our one LAFState
instance.
*/
private static final Object lafStateACKey = new StringBuffer("LookAndFeel State");
/* Lock object used in place of class object for synchronization. (4187686)
*/
private static final Object classLock = new Object();
/* Cache the last referenced LAFState to improve performance
* when accessing it. The cache is based on last thread rather
* than last AppContext because of the cost of looking up the
* AppContext each time. Since most Swing UI work is on the
* EventDispatchThread, this hits often enough to justify the
* overhead. (4193032)
*/
private static Thread currentLAFStateThread = null;
private static LAFState currentLAFState = null;
/**
* Return the LAFState
object, lazily create one if necessary.
* All access to the LAFState
fields is done via this method,
* for example:
*
* getLAFState().initialized = true; **/ private static LAFState getLAFState() { // First check whether we're running on the same thread as // the last request. Thread thisThread = Thread.currentThread(); if (thisThread == currentLAFStateThread) { return currentLAFState; } LAFState rv = (LAFState)SwingUtilities.appContextGet(lafStateACKey); if (rv == null) { synchronized (classLock) { rv = (LAFState)SwingUtilities.appContextGet(lafStateACKey); if (rv == null) { SwingUtilities.appContextPut(lafStateACKey, (rv = new LAFState())); } } } currentLAFStateThread = thisThread; currentLAFState = rv; return rv; } /* Keys used for the properties file in
LookAndFeel
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 UIManager
s
* LookAndFeelInfo
object.
*
* @param name a String
specifying the name of
* the look and feel
* @param className a String
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 String
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
* LookAndFeel
* @see LookAndFeel
*/
public String getClassName() {
return className;
}
/**
* Returns a string that displays and identifies this
* object's properties.
*
* @return a String
representation of this object
*/
public String toString() {
return getClass().getName() + "[" + getName() + " " + getClassName() + "]";
}
}
/**
* The default value of installedLAFS
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 iLAFs = new ArrayList(4);
iLAFs.add(new LookAndFeelInfo(
"Metal", "javax.swing.plaf.metal.MetalLookAndFeel"));
iLAFs.add(new LookAndFeelInfo("CDE/Motif",
"com.sun.java.swing.plaf.motif.MotifLookAndFeel"));
// Only include windows on Windows boxs.
String osName = (String)AccessController.doPrivileged(
new GetPropertyAction("os.name"));
if (osName != null && osName.indexOf("Windows") != -1) {
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 = (LookAndFeelInfo[])iLAFs.toArray(
new LookAndFeelInfo[iLAFs.size()]);
}
/**
* Returns an array of objects that provide some information about the
* LookAndFeel
implementations that have been installed with this
* software development kit. The LookAndFeel
info objects can
* used by an application to construct a menu of look and feel options for
* the user or to set the look and feel at start up time. Note that
* we do not return the LookAndFeel
classes themselves here to
* avoid the cost of unnecessarily loading them.
*
* Given a LookAndFeelInfo
object one can set the current
* look and feel like this:
*
* UIManager.setLookAndFeel(info.getClassName()); ** @return an array of
LookAndFeelInfo
objects
*
* @see #setLookAndFeel
*/
public static LookAndFeelInfo[] getInstalledLookAndFeels() {
maybeInitialize();
LookAndFeelInfo[] ilafs = installedLAFs;
LookAndFeelInfo[] rv = new LookAndFeelInfo[ilafs.length];
System.arraycopy(ilafs, 0, rv, 0, ilafs.length);
return rv;
}
/**
* Replaces the current array of installed LookAndFeelInfos
.
* @param infos new array of LookAndFeelInfo
objects
*
* @see #getInstalledLookAndFeels
*/
public static void setInstalledLookAndFeels(LookAndFeelInfo[] infos)
throws SecurityException
{
LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length];
System.arraycopy(infos, 0, newInfos, 0, infos.length);
installedLAFs = newInfos;
}
/**
* Adds the specified look and feel to the current array and
* then calls {@link #setInstalledLookAndFeels}.
* @param info a LookAndFeelInfo
object that names the
* look and feel and identifies that class that implements it
*/
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);
}
/**
* Creates a new look and feel and adds it to the current array.
* Then calls {@link #setInstalledLookAndFeels}.
*
* @param name a String
specifying the name of the
* look and feel
* @param className a String
specifying the class name
* that implements the look and feel
*/
public static void installLookAndFeel(String name, String className) {
installLookAndFeel(new LookAndFeelInfo(name, className));
}
/**
* Returns the current default look and feel or null
.
*
* @return the current default look and feel, or null
* @see #setLookAndFeel
*/
public static LookAndFeel getLookAndFeel() {
maybeInitialize();
return getLAFState().lookAndFeel;
}
/**
* Sets the current default look and feel using a
* LookAndFeel
object.
*
* This is a JavaBeans bound property.
*
* @param newLookAndFeel the LookAndFeel
object
* @exception UnsupportedLookAndFeelException if
* lnf.isSupportedLookAndFeel()
is 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);
}
}
/**
* Sets the current default look and feel using a class name.
*
* @param className a string specifying the name of the class that implements
* the look and feel
* @exception ClassNotFoundException if the LookAndFeel
* 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
* lnf.isSupportedLookAndFeel()
is false
*/
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 LookAndFeel
class that implements
* the native systems look and feel if there is one, otherwise
* the name of the default cross platform LookAndFeel
* class. If the system property swing.systemlaf
has been
* defined, its value will be returned.
*
* @return the String
of the LookAndFeel
* class
*
* @see #setLookAndFeel
* @see #getCrossPlatformLookAndFeelClassName
*/
public static String getSystemLookAndFeelClassName() {
String systemLAF = (String)AccessController.doPrivileged(
new GetPropertyAction("swing.systemlaf"));
if (systemLAF != null) {
return systemLAF;
}
String osName = (String)AccessController.doPrivileged(
new GetPropertyAction("os.name"));
if (osName != null) {
if (osName.indexOf("Windows") != -1) {
return "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
}
else {
String desktop = (String)AccessController.doPrivileged(
new GetPropertyAction("sun.desktop"));
if ("gnome".equals(desktop)) {
// May be set on Linux and Solaris boxs.
return "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
}
if ((osName.indexOf("Solaris") != -1) ||
(osName.indexOf("SunOS") != -1)) {
return "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
}
}
}
return getCrossPlatformLookAndFeelClassName();
}
/**
* Returns the name of the LookAndFeel
class that implements
* the default cross platform look and feel -- the Java
* Look and Feel (JLF). If the system property
* swing.crossplatformlaf
has been
* defined, its value will be returned.
*
* @return a string with the JLF implementation-class
* @see #setLookAndFeel
* @see #getSystemLookAndFeelClassName
*/
public static String getCrossPlatformLookAndFeelClassName() {
String laf = (String)AccessController.doPrivileged(
new GetPropertyAction("swing.crossplatformlaf"));
if (laf != null) {
return laf;
}
return "javax.swing.plaf.metal.MetalLookAndFeel";
}
/**
* Returns the default values for this look and feel.
*
* @return a UIDefaults
object containing the default values
*/
public static UIDefaults getDefaults() {
maybeInitialize();
return getLAFState().multiUIDefaults;
}
/**
* Returns a drawing font from the defaults table.
*
* @param key an Object
specifying the font
* @return the Font
object
*/
public static Font getFont(Object key) {
return getDefaults().getFont(key);
}
/**
* Returns a drawing font from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the font
* @param l the Locale
for which the font is desired
* @return the Font
object
* @since 1.4
*/
public static Font getFont(Object key, Locale l) {
return getDefaults().getFont(key,l);
}
/**
* Returns a drawing color from the defaults table.
*
* @param key an Object
specifying the color
* @return the Color
object
*/
public static Color getColor(Object key) {
return getDefaults().getColor(key);
}
/**
* Returns a drawing color from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the color
* @param l the Locale
for which the color is desired
* @return the Color
object
* @since 1.4
*/
public static Color getColor(Object key, Locale l) {
return getDefaults().getColor(key,l);
}
/**
* Returns an Icon
from the defaults table.
*
* @param key an Object
specifying the icon
* @return the Icon
object
*/
public static Icon getIcon(Object key) {
return getDefaults().getIcon(key);
}
/**
* Returns an Icon
from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the icon
* @param l the Locale
for which the icon is desired
* @return the Icon
object
* @since 1.4
*/
public static Icon getIcon(Object key, Locale l) {
return getDefaults().getIcon(key,l);
}
/**
* Returns a border from the defaults table.
*
* @param key an Object
specifying the border
* @return the Border
object
*/
public static Border getBorder(Object key) {
return getDefaults().getBorder(key);
}
/**
* Returns a border from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the border
* @param l the Locale
for which the border is desired
* @return the Border
object
* @since 1.4
*/
public static Border getBorder(Object key, Locale l) {
return getDefaults().getBorder(key,l);
}
/**
* Returns a string from the defaults table.
*
* @param key an Object
specifying the string
* @return the String
*/
public static String getString(Object key) {
return getDefaults().getString(key);
}
/**
* Returns a string from the defaults table that is appropriate for the
* given locale.
*
* @param key an Object
specifying the string
* @param l the Locale
for which the string is desired
* @return the String
*/
public static String getString(Object key, Locale l) {
return getDefaults().getString(key,l);
}
/**
* Returns a string from the defaults table that is appropriate for the
* given locale.
*
* @param key an Object
specifying the string
* @param c Component used to determine Locale, null implies use the
* default Locale.
* @return the String
*/
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 table.
*
* @param key an Object
specifying the int
* @return the int
*/
public static int getInt(Object key) {
return getDefaults().getInt(key);
}
/**
* Returns an integer from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the int
* @param l the Locale
for which the int is desired
* @return the int
* @since 1.4
*/
public static int getInt(Object key, Locale l) {
return getDefaults().getInt(key,l);
}
/**
* Returns an integer from the defaults table. If key
does
* not map to a valid Integer
, or can not be convered from
* a String
to an integer, default
is
* returned.
*
* @param key an Object
specifying the int
* @param defaultValue Returned value if key
is not available,
* or is not an Integer
* @return the int
*/
static int getInt(Object key, int defaultValue) {
Object value = UIManager.get(key);
if (value instanceof Integer) {
return ((Integer)value).intValue();
}
if (value instanceof String) {
try {
return Integer.parseInt((String)value);
} catch (NumberFormatException nfe) {}
}
return defaultValue;
}
/**
* Returns a boolean from the defaults table which is associated with
* the key value. If the key is not found or the key doesn't represent
* a boolean value then false will be returned.
*
* @param key an Object
specifying the key for the desired boolean value
* @return the boolean value corresponding to the key
* @since 1.4
*/
public static boolean getBoolean(Object key) {
return getDefaults().getBoolean(key);
}
/**
* Returns a boolean from the defaults table which is associated with
* the key value and the given Locale
. If the key is not
* found or the key doesn't represent
* a boolean value then false will be returned.
*
* @param key an Object
specifying the key for the desired
* boolean value
* @param l the Locale
for which the boolean is desired
* @return the boolean value corresponding to the key
* @since 1.4
*/
public static boolean getBoolean(Object key, Locale l) {
return getDefaults().getBoolean(key,l);
}
/**
* Returns an Insets
object from the defaults table.
*
* @param key an Object
specifying the Insets
object
* @return the Insets
object
*/
public static Insets getInsets(Object key) {
return getDefaults().getInsets(key);
}
/**
* Returns an Insets
object from the defaults table that is
* appropriate for the given locale.
*
* @param key an Object
specifying the Insets
object
* @param l the Locale
for which the object is desired
* @return the Insets
object
* @since 1.4
*/
public static Insets getInsets(Object key, Locale l) {
return getDefaults().getInsets(key,l);
}
/**
* Returns a dimension from the defaults table.
*
* @param key an Object
specifying the dimension object
* @return the Dimension
object
*/
public static Dimension getDimension(Object key) {
return getDefaults().getDimension(key);
}
/**
* Returns a dimension from the defaults table that is appropriate
* for the given locale.
*
* @param key an Object
specifying the dimension object
* @param l the Locale
for which the object is desired
* @return the Dimension
object
* @since 1.4
*/
public static Dimension getDimension(Object key, Locale l) {
return getDefaults().getDimension(key,l);
}
/**
* Returns an object from the defaults table.
*
* @param key an Object
specifying the desired object
* @return the Object
*/
public static Object get(Object key) {
return getDefaults().get(key);
}
/**
* Returns an object from the defaults table that is appropriate for
* the given locale.
*
* @param key an Object
specifying the desired object
* @param l the Locale
for which the object is desired
* @return the Object
*/
public static Object get(Object key, Locale l) {
return getDefaults().get(key,l);
}
/**
* Stores an object in the defaults table.
*
* @param key an Object
specifying the retrieval key
* @param value the Object
to store
* @return the Object
returned by {@link UIDefaults#put}
*/
public static Object put(Object key, Object value) {
return getDefaults().put(key, value);
}
/**
* Returns the L&F object that renders the target component.
*
* @param target the JComponent
to render
* @return the ComponentUI
object that renders the target component
*/
public static ComponentUI getUI(JComponent target) {
maybeInitialize();
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 default values for this look and feel.
*
* @return an UIDefaults
object containing the default values
*/
public static UIDefaults getLookAndFeelDefaults() {
maybeInitialize();
return getLAFState().getLookAndFeelDefaults();
}
/**
* Finds the Multiplexing LookAndFeel
.
*/
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 LookAndFeel
to the list of auxiliary look and feels.
* The auxiliary look and feels tell the multiplexing look and feel what
* other LookAndFeel
classes for a component instance are to be used
* in addition to the default LookAndFeel
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.
*
Note these are not the same as the installed look and feels.
*
* @param laf the LookAndFeel
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 v = getLAFState().auxLookAndFeels;
if (v == null) {
v = new Vector();
}
if (!v.contains(laf)) {
v.addElement(laf);
laf.initialize();
getLAFState().auxLookAndFeels = v;
if (getLAFState().multiLookAndFeel == null) {
getLAFState().multiLookAndFeel = getMultiLookAndFeel();
}
}
}
/**
* Removes a LookAndFeel
from the list of auxiliary look and feels.
* The auxiliary look and feels tell the multiplexing look and feel what
* other LookAndFeel
classes for a component instance are to be used
* in addition to the default LookAndFeel
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.
*
Note these are not the same as the installed look and feels.
* @return true if the LookAndFeel
was removed from the list
* @see #removeAuxiliaryLookAndFeel
* @see #getAuxiliaryLookAndFeels
* @see #setLookAndFeel
* @see #getInstalledLookAndFeels
*/
static public boolean removeAuxiliaryLookAndFeel(LookAndFeel laf) {
maybeInitialize();
boolean result;
Vector 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 null
).
* The auxiliary look and feels tell the multiplexing look and feel what
* other LookAndFeel
classes for a component instance are
* to be used in addition to the default LookAndFeel class when creating a
* multiplexing UI.
*
Note these are not the same as the installed look and feels.
*
* @return list of auxiliary LookAndFeel
s or null
* @see #addAuxiliaryLookAndFeel
* @see #removeAuxiliaryLookAndFeel
* @see #setLookAndFeel
* @see #getInstalledLookAndFeels
*/
static public LookAndFeel[] getAuxiliaryLookAndFeels() {
maybeInitialize();
Vector 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] = (LookAndFeel)v.elementAt(i);
}
return rv;
}
}
/**
* Adds a PropertyChangeListener
to the listener list.
* The listener is registered for all properties.
*
* @param listener the PropertyChangeListener
to be added
* @see java.beans.PropertyChangeSupport
*/
public static void addPropertyChangeListener(PropertyChangeListener listener)
{
synchronized (classLock) {
getLAFState().getPropertyChangeSupport(true).
addPropertyChangeListener(listener);
}
}
/**
* Removes a PropertyChangeListener
from the listener list.
* This removes a PropertyChangeListener
that was registered
* for all properties.
*
* @param listener the PropertyChangeListener
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 PropertyChangeListener
s added
* to this UIManager with addPropertyChangeListener().
*
* @return all of the PropertyChangeListener
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() {
public Object run() {
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 swing.properties file exist and it has a swing.installedlafs property
* then initialize the installedLAFs
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 lafs = new Vector();
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 ilafs = new Vector(lafs.size());
for(int i = 0; i < lafs.size(); i++) {
String laf = (String)lafs.elementAt(i);
String name = swingProps.getProperty(makeInstalledLAFKey(laf, "name"), laf);
String cls = swingProps.getProperty(makeInstalledLAFKey(laf, "class"));
if (cls != null) {
ilafs.addElement(new LookAndFeelInfo(name, cls));
}
}
installedLAFs = new LookAndFeelInfo[ilafs.size()];
for(int i = 0; i < ilafs.size(); i++) {
installedLAFs[i] = (LookAndFeelInfo)(ilafs.elementAt(i));
}
}
/**
* 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;
}
String metalLnf = getCrossPlatformLookAndFeelClassName();
String lnfDefault = metalLnf;
String lnfName = "AppContext
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();
}
}
}
/*
* Only called by maybeInitialize().
*/
private static void initialize() {
Properties swingProps = loadSwingProperties();
initializeSystemDefaults(swingProps);
initializeDefaultLAF(swingProps);
initializeAuxiliaryLAFs(swingProps);
initializeInstalledLAFs(swingProps);
// Enable the Swing default LayoutManager.
String toolkitName = Toolkit.getDefaultToolkit().getClass().getName();
// don't set default policy if this is XAWT.
if (!"sun.awt.X11.XToolkit".equals(toolkitName)) {
if (FocusManager.isFocusManagerEnabled()) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setDefaultFocusTraversalPolicy(
new LayoutFocusTraversalPolicy());
}
}
// 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 && !((JComponent)c).isEnabled())) &&
JComponent.KeyboardState.shouldProcess(e) &&
SwingUtilities.processKeyBindings(e)) {
e.consume();
return true;
}
return false;
}
});
}
}