UIManager.
*
* 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 JavaBeans™
* has been added to the
* If a mapping for
* This method is used by
* A java.beans package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see UIManager
* @author Hans Muller
* @since 1.2
*/
@SuppressWarnings("serial") // Same-version serialization only
public class UIDefaults extends Hashtable
Object[] uiDefaults = {
"Font", new Font("Dialog", Font.BOLD, 12),
"Color", Color.red,
"five", new Integer(5)
}
UIDefaults myDefaults = new UIDefaults(uiDefaults);
*
* @param keyValueList an array of objects containing the key/value
* pairs
*/
public UIDefaults(Object[] keyValueList) {
super(keyValueList.length / 2);
for(int i = 0; i < keyValueList.length; i += 2) {
super.put(keyValueList[i], keyValueList[i + 1]);
}
}
/**
* Returns the value for key. If the value is a
* UIDefaults.LazyValue then the real
* value is computed with LazyValue.createValue(),
* the table entry is replaced, and the real value is returned.
* If the value is an UIDefaults.ActiveValue
* the table entry is not replaced - the value is computed
* with ActiveValue.createValue() for each
* get() call.
*
* If the key is not found in the table then it is searched for in the list
* of resource bundles maintained by this object. The resource bundles are
* searched most recently added first using the locale returned by
* getDefaultLocale. LazyValues and
* ActiveValues are not supported in the resource bundles.
*
* @param key the desired key
* @return the value for key
* @see LazyValue
* @see ActiveValue
* @see java.util.Hashtable#get
* @see #getDefaultLocale
* @see #addResourceBundle
* @since 1.4
*/
public Object get(Object key) {
Object value = getFromHashtable( key );
return (value != null) ? value : getFromResourceBundle(key, null);
}
/**
* Looks up the given key in our Hashtable and resolves LazyValues
* or ActiveValues.
*/
private Object getFromHashtable(final Object key) {
/* Quickly handle the common case, without grabbing
* a lock.
*/
Object value = super.get(key);
if ((value != PENDING) &&
!(value instanceof ActiveValue) &&
!(value instanceof LazyValue)) {
return value;
}
/* If the LazyValue for key is being constructed by another
* thread then wait and then return the new value, otherwise drop
* the lock and construct the ActiveValue or the LazyValue.
* We use the special value PENDING to mark LazyValues that
* are being constructed.
*/
synchronized(this) {
value = super.get(key);
if (value == PENDING) {
do {
try {
this.wait();
}
catch (InterruptedException e) {
}
value = super.get(key);
}
while(value == PENDING);
return value;
}
else if (value instanceof LazyValue) {
super.put(key, PENDING);
}
else if (!(value instanceof ActiveValue)) {
return value;
}
}
/* At this point we know that the value of key was
* a LazyValue or an ActiveValue.
*/
if (value instanceof LazyValue) {
try {
/* If an exception is thrown we'll just put the LazyValue
* back in the table.
*/
value = ((LazyValue)value).createValue(this);
}
finally {
synchronized(this) {
if (value == null) {
super.remove(key);
}
else {
super.put(key, value);
}
this.notifyAll();
}
}
}
else {
value = ((ActiveValue)value).createValue(this);
}
return value;
}
/**
* Returns the value for key associated with the given locale.
* If the value is a UIDefaults.LazyValue then the real
* value is computed with LazyValue.createValue(),
* the table entry is replaced, and the real value is returned.
* If the value is an UIDefaults.ActiveValue
* the table entry is not replaced - the value is computed
* with ActiveValue.createValue() for each
* get() call.
*
* If the key is not found in the table then it is searched for in the list
* of resource bundles maintained by this object. The resource bundles are
* searched most recently added first using the given locale.
* LazyValues and ActiveValues are not supported
* in the resource bundles.
*
* @param key the desired key
* @param l the desired locale
* @return the value for key
* @see LazyValue
* @see ActiveValue
* @see java.util.Hashtable#get
* @see #addResourceBundle
* @since 1.4
*/
public Object get(Object key, Locale l) {
Object value = getFromHashtable( key );
return (value != null) ? value : getFromResourceBundle(key, l);
}
/**
* Looks up given key in our resource bundles.
*/
private Object getFromResourceBundle(Object key, Locale l) {
if( resourceBundles == null ||
resourceBundles.isEmpty() ||
!(key instanceof String) ) {
return null;
}
// A null locale means use the default locale.
if( l == null ) {
if( defaultLocale == null )
return null;
else
l = defaultLocale;
}
synchronized(this) {
return getResourceCache(l).get(key);
}
}
/**
* Returns a Map of the known resources for the given locale.
*/
private Mapkey to value for all locales.
* If key is a string and the new value isn't
* equal to the old one, fire a PropertyChangeEvent.
* If value is null, the key is removed from the table.
*
* @param key the unique Object who's value will be used
* to retrieve the data value associated with it
* @param value the new Object to store as data under
* that key
* @return the previous Object value, or null
* @see #putDefaults
* @see java.util.Hashtable#put
*/
public Object put(Object key, Object value) {
Object oldValue = (value == null) ? super.remove(key) : super.put(key, value);
if (key instanceof String) {
firePropertyChange((String)key, oldValue, value);
}
return oldValue;
}
/**
* Puts all of the key/value pairs in the database and
* unconditionally generates one PropertyChangeEvent.
* The events oldValue and newValue will be null and its
* propertyName will be "UIDefaults". The key/value pairs are
* added for all locales.
*
* @param keyValueList an array of key/value pairs
* @see #put
* @see java.util.Hashtable#put
*/
public void putDefaults(Object[] keyValueList) {
for(int i = 0, max = keyValueList.length; i < max; i += 2) {
Object value = keyValueList[i + 1];
if (value == null) {
super.remove(keyValueList[i]);
}
else {
super.put(keyValueList[i], value);
}
}
firePropertyChange("UIDefaults", null, null);
}
/**
* If the value of key is a Font return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is a Font,
* return the Font object; otherwise return
* null
*/
public Font getFont(Object key) {
Object value = get(key);
return (value instanceof Font) ? (Font)value : null;
}
/**
* If the value of key for the given Locale
* is a Font return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is a Font,
* return the Font object; otherwise return
* null
* @since 1.4
*/
public Font getFont(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Font) ? (Font)value : null;
}
/**
* If the value of key is a Color return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is a Color,
* return the Color object; otherwise return
* null
*/
public Color getColor(Object key) {
Object value = get(key);
return (value instanceof Color) ? (Color)value : null;
}
/**
* If the value of key for the given Locale
* is a Color return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is a Color,
* return the Color object; otherwise return
* null
* @since 1.4
*/
public Color getColor(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Color) ? (Color)value : null;
}
/**
* If the value of key is an Icon return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is an Icon,
* return the Icon object; otherwise return
* null
*/
public Icon getIcon(Object key) {
Object value = get(key);
return (value instanceof Icon) ? (Icon)value : null;
}
/**
* If the value of key for the given Locale
* is an Icon return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is an Icon,
* return the Icon object; otherwise return
* null
* @since 1.4
*/
public Icon getIcon(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Icon) ? (Icon)value : null;
}
/**
* If the value of key is a Border return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is a Border,
* return the Border object; otherwise return
* null
*/
public Border getBorder(Object key) {
Object value = get(key);
return (value instanceof Border) ? (Border)value : null;
}
/**
* If the value of key for the given Locale
* is a Border return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is a Border,
* return the Border object; otherwise return
* null
* @since 1.4
*/
public Border getBorder(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Border) ? (Border)value : null;
}
/**
* If the value of key is a String return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is a String,
* return the String object; otherwise return
* null
*/
public String getString(Object key) {
Object value = get(key);
return (value instanceof String) ? (String)value : null;
}
/**
* If the value of key for the given Locale
* is a String return it, otherwise return null.
* @param key the desired key
* @param l the desired Locale
* @return if the value for key for the given
* Locale is a String,
* return the String object; otherwise return
* null
* @since 1.4
*/
public String getString(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof String) ? (String)value : null;
}
/**
* If the value of key is an Integer return its
* integer value, otherwise return 0.
* @param key the desired key
* @return if the value for key is an Integer,
* return its value, otherwise return 0
*/
public int getInt(Object key) {
Object value = get(key);
return (value instanceof Integer) ? ((Integer)value).intValue() : 0;
}
/**
* If the value of key for the given Locale
* is an Integer return its integer value, otherwise return 0.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is an Integer,
* return its value, otherwise return 0
* @since 1.4
*/
public int getInt(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Integer) ? ((Integer)value).intValue() : 0;
}
/**
* If the value of key is boolean, return the
* boolean value, otherwise return false.
*
* @param key an Object specifying the key for the desired boolean value
* @return if the value of key is boolean, return the
* boolean value, otherwise return false.
* @since 1.4
*/
public boolean getBoolean(Object key) {
Object value = get(key);
return (value instanceof Boolean) ? ((Boolean)value).booleanValue() : false;
}
/**
* If the value of key for the given Locale
* is boolean, return the boolean value, otherwise return false.
*
* @param key an Object specifying the key for the desired boolean value
* @param l the desired locale
* @return if the value for key and Locale
* is boolean, return the
* boolean value, otherwise return false.
* @since 1.4
*/
public boolean getBoolean(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Boolean) ? ((Boolean)value).booleanValue() : false;
}
/**
* If the value of key is an Insets return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is an Insets,
* return the Insets object; otherwise return
* null
*/
public Insets getInsets(Object key) {
Object value = get(key);
return (value instanceof Insets) ? (Insets)value : null;
}
/**
* If the value of key for the given Locale
* is an Insets return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is an Insets,
* return the Insets object; otherwise return
* null
* @since 1.4
*/
public Insets getInsets(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Insets) ? (Insets)value : null;
}
/**
* If the value of key is a Dimension return it,
* otherwise return null.
* @param key the desired key
* @return if the value for key is a Dimension,
* return the Dimension object; otherwise return
* null
*/
public Dimension getDimension(Object key) {
Object value = get(key);
return (value instanceof Dimension) ? (Dimension)value : null;
}
/**
* If the value of key for the given Locale
* is a Dimension return it, otherwise return null.
* @param key the desired key
* @param l the desired locale
* @return if the value for key and Locale
* is a Dimension,
* return the Dimension object; otherwise return
* null
* @since 1.4
*/
public Dimension getDimension(Object key, Locale l) {
Object value = get(key,l);
return (value instanceof Dimension) ? (Dimension)value : null;
}
/**
* The value of get(uidClassID) must be the
* String name of a
* class that implements the corresponding ComponentUI
* class. If the class hasn't been loaded before, this method looks
* up the class with uiClassLoader.loadClass() if a non
* null
* class loader is provided, classForName() otherwise.
* uiClassID exists or if the specified
* class can't be found, return null.
* getUI, it's usually
* not necessary to call it directly.
*
* @param uiClassID a string containing the class ID
* @param uiClassLoader the object which will load the class
* @return the value of Class.forName(get(uidClassID))
* @see #getUI
*/
public Class
getUIClass(String uiClassID, ClassLoader uiClassLoader)
{
try {
String className = (String)get(uiClassID);
if (className != null) {
ReflectUtil.checkPackageAccess(className);
Class cls = (Class)get(className);
if (cls == null) {
if (uiClassLoader == null) {
cls = SwingUtilities.loadSystemClass(className);
}
else {
cls = uiClassLoader.loadClass(className);
}
if (cls != null) {
// Save lookup for future use, as forName is slow.
put(className, cls);
}
}
@SuppressWarnings("unchecked")
Class tmp = (Class)cls;
return tmp;
}
}
catch (ClassNotFoundException | ClassCastException e) {
return null;
}
return null;
}
/**
* Returns the L&F class that renders this component.
*
* @param uiClassID a string containing the class ID
* @return the Class object returned by
* getUIClass(uiClassID, null)
*/
public Class getUIClass(String uiClassID) {
return getUIClass(uiClassID, null);
}
/**
* If getUI() fails for any reason,
* it calls this method before returning null.
* Subclasses may choose to do more or less here.
*
* @param msg message string to print
* @see #getUI
*/
protected void getUIError(String msg) {
System.err.println("UIDefaults.getUI() failed: " + msg);
try {
throw new Error();
}
catch (Throwable e) {
e.printStackTrace();
}
}
/**
* Creates an ComponentUI implementation for the
* specified component. In other words create the look
* and feel specific delegate object for target.
* This is done in two steps:
*
*
* @param target the ComponentUI implementation
* class under the value returned by target.getUIClassID().
* createUI()
* method to construct a look and feel delegate.
* JComponent which needs a UI
* @return the ComponentUI object
*/
public ComponentUI getUI(JComponent target) {
Object cl = get("ClassLoader");
ClassLoader uiClassLoader =
(cl != null) ? (ClassLoader)cl : target.getClass().getClassLoader();
Class uiClass = getUIClass(target.getUIClassID(), uiClassLoader);
Object uiObject = null;
if (uiClass == null) {
getUIError("no ComponentUI class for: " + target);
}
else {
try {
Method m = (Method)get(uiClass);
if (m == null) {
m = uiClass.getMethod("createUI", new Class[]{JComponent.class});
put(uiClass, m);
}
uiObject = MethodUtil.invoke(m, null, new Object[]{target});
}
catch (NoSuchMethodException e) {
getUIError("static createUI() method not found in " + uiClass);
}
catch (Exception e) {
getUIError("createUI() failed for " + target + " " + e);
}
}
return (ComponentUI)uiObject;
}
/**
* Adds a PropertyChangeListener to the listener list.
* The listener is registered for all properties.
* PropertyChangeEvent will get fired whenever a default
* is changed.
*
* @param listener the PropertyChangeListener to be added
* @see java.beans.PropertyChangeSupport
*/
public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
if (changeSupport == null) {
changeSupport = new SwingPropertyChangeSupport(this);
}
changeSupport.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 synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
if (changeSupport != null) {
changeSupport.removePropertyChangeListener(listener);
}
}
/**
* Returns an array of all the PropertyChangeListeners added
* to this UIDefaults with addPropertyChangeListener().
*
* @return all of the PropertyChangeListeners added or an empty
* array if no listeners have been added
* @since 1.4
*/
public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners();
}
/**
* Support for reporting bound property changes. If oldValue and
* newValue are not equal and the PropertyChangeEventx
* listener list isn't empty, then fire a
* PropertyChange event to each listener.
*
* @param propertyName the programmatic name of the property
* that was changed
* @param oldValue the old value of the property
* @param newValue the new value of the property
* @see java.beans.PropertyChangeSupport
*/
protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
if (changeSupport != null) {
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
}
/**
* Adds a resource bundle to the list of resource bundles that are
* searched for localized values. Resource bundles are searched in the
* reverse order they were added. In other words, the most recently added
* bundle is searched first.
*
* @param bundleName the base name of the resource bundle to be added
* @see java.util.ResourceBundle
* @see #removeResourceBundle
* @since 1.4
*/
public synchronized void addResourceBundle( String bundleName ) {
if( bundleName == null ) {
return;
}
if( resourceBundles == null ) {
resourceBundles = new Vectorget methods that do not take a
* locale argument. As of release 1.4, Swing UI objects should retrieve
* localized values using the locale of their component rather than the
* default locale. The default locale exists to provide compatibility with
* pre 1.4 behaviour.
*
* @param l the new default locale
* @see #getDefaultLocale
* @see #get(Object)
* @see #get(Object,Locale)
* @since 1.4
*/
public void setDefaultLocale( Locale l ) {
defaultLocale = l;
}
/**
* Returns the default locale. The default locale is used in retrieving
* localized values via get methods that do not take a
* locale argument. As of release 1.4, Swing UI objects should retrieve
* localized values using the locale of their component rather than the
* default locale. The default locale exists to provide compatibility with
* pre 1.4 behaviour.
*
* @return the default locale
* @see #setDefaultLocale
* @see #get(Object)
* @see #get(Object,Locale)
* @since 1.4
*/
public Locale getDefaultLocale() {
return defaultLocale;
}
/**
* This class enables one to store an entry in the defaults
* table that isn't constructed until the first time it's
* looked up with one of the getXXX(key) methods.
* Lazy values are useful for defaults that are expensive
* to construct or are seldom retrieved. The first time
* a LazyValue is retrieved its "real value" is computed
* by calling LazyValue.createValue() and the real
* value is used to replace the LazyValue in the
* UIDefaults
* table. Subsequent lookups for the same key return
* the real value. Here's an example of a LazyValue
* that constructs a Border:
*
* Object borderLazyValue = new UIDefaults.LazyValue() {
* public Object createValue(UIDefaults table) {
* return new BorderFactory.createLoweredBevelBorder();
* }
* };
*
* uiDefaultsTable.put("MyBorder", borderLazyValue);
*
*
* @see UIDefaults#get
*/
public interface LazyValue {
/**
* Creates the actual value retrieved from the UIDefaults
* table. When an object that implements this interface is
* retrieved from the table, this method is used to create
* the real value, which is then stored in the table and
* returned to the calling method.
*
* @param table a UIDefaults table
* @return the created Object
*/
Object createValue(UIDefaults table);
}
/**
* This class enables one to store an entry in the defaults
* table that's constructed each time it's looked up with one of
* the getXXX(key) methods. Here's an example of
* an ActiveValue that constructs a
* DefaultListCellRenderer:
*
* Object cellRendererActiveValue = new UIDefaults.ActiveValue() {
* public Object createValue(UIDefaults table) {
* return new DefaultListCellRenderer();
* }
* };
*
* uiDefaultsTable.put("MyRenderer", cellRendererActiveValue);
*
*
* @see UIDefaults#get
*/
public interface ActiveValue {
/**
* Creates the value retrieved from the UIDefaults table.
* The object is created each time it is accessed.
*
* @param table a UIDefaults table
* @return the created Object
*/
Object createValue(UIDefaults table);
}
/**
* This class provides an implementation of LazyValue
* which can be
* used to delay loading of the Class for the instance to be created.
* It also avoids creation of an anonymous inner class for the
* LazyValue
* subclass. Both of these improve performance at the time that a
* a Look and Feel is loaded, at the cost of a slight performance
* reduction the first time createValue is called
* (since Reflection APIs are used).
* @since 1.3
*/
public static class ProxyLazyValue implements LazyValue {
private AccessControlContext acc;
private String className;
private String methodName;
private Object[] args;
/**
* Creates a LazyValue which will construct an instance
* when asked.
*
* @param c a String specifying the classname
* of the instance to be created on demand
*/
public ProxyLazyValue(String c) {
this(c, (String)null);
}
/**
* Creates a LazyValue which will construct an instance
* when asked.
*
* @param c a String specifying the classname of
* the class
* containing a static method to be called for
* instance creation
* @param m a String specifying the static
* method to be called on class c
*/
public ProxyLazyValue(String c, String m) {
this(c, m, null);
}
/**
* Creates a LazyValue which will construct an instance
* when asked.
*
* @param c a String specifying the classname
* of the instance to be created on demand
* @param o an array of Objects to be passed as
* paramaters to the constructor in class c
*/
public ProxyLazyValue(String c, Object[] o) {
this(c, null, o);
}
/**
* Creates a LazyValue which will construct an instance
* when asked.
*
* @param c a String specifying the classname
* of the class
* containing a static method to be called for
* instance creation.
* @param m a String specifying the static method
* to be called on class c
* @param o an array of Objects to be passed as
* paramaters to the static method in class c
*/
public ProxyLazyValue(String c, String m, Object[] o) {
acc = AccessController.getContext();
className = c;
methodName = m;
if (o != null) {
args = o.clone();
}
}
/**
* Creates the value retrieved from the UIDefaults table.
* The object is created each time it is accessed.
*
* @param table a UIDefaults table
* @return the created Object
*/
public Object createValue(final UIDefaults table) {
// In order to pick up the security policy in effect at the
// time of creation we use a doPrivileged with the
// AccessControlContext that was in place when this was created.
if (acc == null && System.getSecurityManager() != null) {
throw new SecurityException("null AccessControlContext");
}
return AccessController.doPrivileged(new PrivilegedAction