/*
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.swing;


import javax.swing.plaf.ComponentUI;
import javax.swing.border.*;
import javax.swing.event.SwingPropertyChangeSupport;

import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.ResourceBundle;
import java.util.ResourceBundle.Control;
import java.util.Locale;
import java.util.Vector;
import java.util.MissingResourceException;
import java.awt.Font;
import java.awt.Color;
import java.awt.Insets;
import java.awt.Dimension;
import java.beans.PropertyChangeListener;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;

import sun.reflect.misc.MethodUtil;
import sun.reflect.misc.ReflectUtil;
import sun.swing.SwingUtilities2;
import sun.util.CoreResourceBundleControl;

/**
 * A table of defaults for Swing components. Applications can set/get
 * default values via the <code>UIManager</code>.
 * <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&trade;
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @see UIManager
 * @author Hans Muller
 */
public class UIDefaults extends Hashtable<Object,Object>
{
 private static final Object PENDING = new Object();

 private SwingPropertyChangeSupport changeSupport;

 private Vector<String> resourceBundles;

 private Locale defaultLocale = Locale.getDefault();

 /**
 * Maps from a Locale to a cached Map of the ResourceBundle. This is done
 * so as to avoid an exception being thrown when a value is asked for.
 * Access to this should be done while holding a lock on the
 * UIDefaults, eg synchronized(this).
 */
 private Map<Locale, Map<String, Object>> resourceCache;

 /**
 * Creates an empty defaults table.
 */
 public UIDefaults() {
 this(700, .75f);
 }

 /**
 * Creates an empty defaults table with the specified initial capacity and
 * load factor.
 *
 * @param initialCapacity the initial capacity of the defaults table
 * @param loadFactor the load factor of the defaults table
 * @see java.util.Hashtable
 * @since 1.6
 */
 public UIDefaults(int initialCapacity, float loadFactor) {
 super(initialCapacity, loadFactor);
 resourceCache = new HashMap<Locale, Map<String, Object>>();
 }


 /**
 * Creates a defaults table initialized with the specified
 * key/value pairs. For example:
 * <pre>
 Object[] uiDefaults = {
 "Font", new Font("Dialog", Font.BOLD, 12),
 "Color", Color.red,
 "five", new Integer(5)
 }
 UIDefaults myDefaults = new UIDefaults(uiDefaults);
 * </pre>
 * @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
 * <code>UIDefaults.LazyValue</code> then the real
 * value is computed with <code>LazyValue.createValue()</code>,
 * the table entry is replaced, and the real value is returned.
 * If the value is an <code>UIDefaults.ActiveValue</code>
 * the table entry is not replaced - the value is computed
 * with <code>ActiveValue.createValue()</code> for each
 * <code>get()</code> 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
 * <code>getDefaultLocale</code>. <code>LazyValues</code> and
 * <code>ActiveValues</code> are not supported in the resource bundles.

 *
 * @param key the desired key
 * @return the value for <code>key</code>
 * @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 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 <code>UIDefaults.LazyValue</code> then the real
 * value is computed with <code>LazyValue.createValue()</code>,
 * the table entry is replaced, and the real value is returned.
 * If the value is an <code>UIDefaults.ActiveValue</code>
 * the table entry is not replaced - the value is computed
 * with <code>ActiveValue.createValue()</code> for each
 * <code>get()</code> 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.
 * <code>LazyValues</code> and <code>ActiveValues</code> are not supported
 * in the resource bundles.
 *
 * @param key the desired key
 * @param l the desired <code>locale</code>
 * @return the value for <code>key</code>
 * @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 Map<String, Object> getResourceCache(Locale l) {
 Map<String, Object> values = resourceCache.get(l);

 if (values == null) {
 values = new TextAndMnemonicHashMap();
 for (int i=resourceBundles.size()-1; i >= 0; i--) {
 String bundleName = resourceBundles.get(i);
 try {
 Control c = CoreResourceBundleControl.getRBControlInstance(bundleName);
 ResourceBundle b;
 if (c != null) {
 b = ResourceBundle.getBundle(bundleName, l, c);
 } else {
 b = ResourceBundle.getBundle(bundleName, l,
 ClassLoader.getSystemClassLoader());
 }
 Enumeration keys = b.getKeys();

 while (keys.hasMoreElements()) {
 String key = (String)keys.nextElement();

 if (values.get(key) == null) {
 Object value = b.getObject(key);

 values.put(key, value);
 }
 }
 } catch( MissingResourceException mre ) {
 // Keep looking
 }
 }
 resourceCache.put(l, values);
 }
 return values;
 }

 /**
 * Sets the value of <code>key</code> to <code>value</code> for all locales.
 * If <code>key</code> is a string and the new value isn't
 * equal to the old one, fire a <code>PropertyChangeEvent</code>.
 * If value is <code>null</code>, the key is removed from the table.
 *
 * @param key the unique <code>Object</code> who's value will be used
 * to retrieve the data value associated with it
 * @param value the new <code>Object</code> to store as data under
 * that key
 * @return the previous <code>Object</code> value, or <code>null</code>
 * @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 <code>PropertyChangeEvent</code>.
 * The events oldValue and newValue will be <code>null</code> and its
 * <code>propertyName</code> 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 <code>key</code> is a <code>Font</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is a <code>Font</code>,
 * return the <code>Font</code> object; otherwise return
 * <code>null</code>
 */
 public Font getFont(Object key) {
 Object value = get(key);
 return (value instanceof Font) ? (Font)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is a <code>Font</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is a <code>Font</code>,
 * return the <code>Font</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is a <code>Color</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is a <code>Color</code>,
 * return the <code>Color</code> object; otherwise return
 * <code>null</code>
 */
 public Color getColor(Object key) {
 Object value = get(key);
 return (value instanceof Color) ? (Color)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is a <code>Color</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is a <code>Color</code>,
 * return the <code>Color</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is an <code>Icon</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is an <code>Icon</code>,
 * return the <code>Icon</code> object; otherwise return
 * <code>null</code>
 */
 public Icon getIcon(Object key) {
 Object value = get(key);
 return (value instanceof Icon) ? (Icon)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is an <code>Icon</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is an <code>Icon</code>,
 * return the <code>Icon</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is a <code>Border</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is a <code>Border</code>,
 * return the <code>Border</code> object; otherwise return
 * <code>null</code>
 */
 public Border getBorder(Object key) {
 Object value = get(key);
 return (value instanceof Border) ? (Border)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is a <code>Border</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is a <code>Border</code>,
 * return the <code>Border</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is a <code>String</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is a <code>String</code>,
 * return the <code>String</code> object; otherwise return
 * <code>null</code>
 */
 public String getString(Object key) {
 Object value = get(key);
 return (value instanceof String) ? (String)value : null;
 }

 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is a <code>String</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired <code>Locale</code>
 * @return if the value for <code>key</code> for the given
 * <code>Locale</code> is a <code>String</code>,
 * return the <code>String</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is an <code>Integer</code> return its
 * integer value, otherwise return 0.
 * @param key the desired key
 * @return if the value for <code>key</code> is an <code>Integer</code>,
 * 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 <code>key</code> for the given <code>Locale</code>
 * is an <code>Integer</code> return its integer value, otherwise return 0.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is an <code>Integer</code>,
 * 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 <code>key</code> is boolean, return the
 * boolean value, otherwise return false.
 *
 * @param key an <code>Object</code> specifying the key for the desired boolean value
 * @return if the value of <code>key</code> 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 <code>key</code> for the given <code>Locale</code>
 * is boolean, return the boolean value, otherwise return false.
 *
 * @param key an <code>Object</code> specifying the key for the desired boolean value
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * 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 <code>key</code> is an <code>Insets</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is an <code>Insets</code>,
 * return the <code>Insets</code> object; otherwise return
 * <code>null</code>
 */
 public Insets getInsets(Object key) {
 Object value = get(key);
 return (value instanceof Insets) ? (Insets)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is an <code>Insets</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is an <code>Insets</code>,
 * return the <code>Insets</code> object; otherwise return
 * <code>null</code>
 * @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 <code>key</code> is a <code>Dimension</code> return it,
 * otherwise return <code>null</code>.
 * @param key the desired key
 * @return if the value for <code>key</code> is a <code>Dimension</code>,
 * return the <code>Dimension</code> object; otherwise return
 * <code>null</code>
 */
 public Dimension getDimension(Object key) {
 Object value = get(key);
 return (value instanceof Dimension) ? (Dimension)value : null;
 }


 /**
 * If the value of <code>key</code> for the given <code>Locale</code>
 * is a <code>Dimension</code> return it, otherwise return <code>null</code>.
 * @param key the desired key
 * @param l the desired locale
 * @return if the value for <code>key</code> and <code>Locale</code>
 * is a <code>Dimension</code>,
 * return the <code>Dimension</code> object; otherwise return
 * <code>null</code>
 * @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 <code>get(uidClassID)</code> must be the
 * <code>String</code> name of a
 * class that implements the corresponding <code>ComponentUI</code>
 * class. If the class hasn't been loaded before, this method looks
 * up the class with <code>uiClassLoader.loadClass()</code> if a non
 * <code>null</code>
 * class loader is provided, <code>classForName()</code> otherwise.
 * <p>
 * If a mapping for <code>uiClassID</code> exists or if the specified
 * class can't be found, return <code>null</code>.
 * <p>
 * This method is used by <code>getUI</code>, 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 <code>Class.forName(get(uidClassID))</code>
 * @see #getUI
 */
 public Class<? extends ComponentUI>
 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);
 }
 }
 return cls;
 }
 }
 catch (ClassNotFoundException e) {
 return null;
 }
 catch (ClassCastException e) {
 return null;
 }
 return null;
 }


 /**
 * Returns the L&amp;F class that renders this component.
 *
 * @param uiClassID a string containing the class ID
 * @return the Class object returned by
 * <code>getUIClass(uiClassID, null)</code>
 */
 public Class<? extends ComponentUI> getUIClass(String uiClassID) {
 return getUIClass(uiClassID, null);
 }


 /**
 * If <code>getUI()</code> fails for any reason,
 * it calls this method before returning <code>null</code>.
 * 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 <code>ComponentUI</code> implementation for the
 * specified component. In other words create the look
 * and feel specific delegate object for <code>target</code>.
 * This is done in two steps:
 * <ul>
 * <li> Look up the name of the <code>ComponentUI</code> implementation
 * class under the value returned by <code>target.getUIClassID()</code>.
 * <li> Use the implementation classes static <code>createUI()</code>
 * method to construct a look and feel delegate.
 * </ul>
 * @param target the <code>JComponent</code> which needs a UI
 * @return the <code>ComponentUI</code> object
 */
 public ComponentUI getUI(JComponent target) {

 Object cl = get("ClassLoader");
 ClassLoader uiClassLoader =
 (cl != null) ? (ClassLoader)cl : target.getClass().getClassLoader();
 Class<? extends ComponentUI> 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 <code>PropertyChangeListener</code> to the listener list.
 * The listener is registered for all properties.
 * <p>
 * A <code>PropertyChangeEvent</code> will get fired whenever a default
 * is changed.
 *
 * @param listener the <code>PropertyChangeListener</code> 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 <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 synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
 if (changeSupport != null) {
 changeSupport.removePropertyChangeListener(listener);
 }
 }


 /**
 * Returns an array of all the <code>PropertyChangeListener</code>s added
 * to this UIDefaults 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 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 <code>PropertyChangeEvent</code>x
 * listener list isn't empty, then fire a
 * <code>PropertyChange</code> 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 Vector<String>(5);
 }
 if (!resourceBundles.contains(bundleName)) {
 resourceBundles.add( bundleName );
 resourceCache.clear();
 }
 }


 /**
 * Removes a resource bundle from the list of resource bundles that are
 * searched for localized defaults.
 *
 * @param bundleName the base name of the resource bundle to be removed
 * @see java.util.ResourceBundle
 * @see #addResourceBundle
 * @since 1.4
 */
 public synchronized void removeResourceBundle( String bundleName ) {
 if( resourceBundles != null ) {
 resourceBundles.remove( bundleName );
 }
 resourceCache.clear();
 }

 /**
 * Sets the default locale. The default locale is used in retrieving
 * localized values via <code>get</code> 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 <code>get</code> 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 <code>getXXX(key)</code> methods.
 * Lazy values are useful for defaults that are expensive
 * to construct or are seldom retrieved. The first time
 * a <code>LazyValue</code> is retrieved its "real value" is computed
 * by calling <code>LazyValue.createValue()</code> and the real
 * value is used to replace the <code>LazyValue</code> in the
 * <code>UIDefaults</code>
 * table. Subsequent lookups for the same key return
 * the real value. Here's an example of a <code>LazyValue</code>
 * that constructs a <code>Border</code>:
 * <pre>
 * Object borderLazyValue = new UIDefaults.LazyValue() {
 * public Object createValue(UIDefaults table) {
 * return new BorderFactory.createLoweredBevelBorder();
 * }
 * };
 *
 * uiDefaultsTable.put("MyBorder", borderLazyValue);
 * </pre>
 *
 * @see UIDefaults#get
 */
 public interface LazyValue {
 /**
 * Creates the actual value retrieved from the <code>UIDefaults</code>
 * 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 <code>UIDefaults</code> table
 * @return the created <code>Object</code>
 */
 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 <code>getXXX(key)</code> methods. Here's an example of
 * an <code>ActiveValue</code> that constructs a
 * <code>DefaultListCellRenderer</code>:
 * <pre>
 * Object cellRendererActiveValue = new UIDefaults.ActiveValue() {
 * public Object createValue(UIDefaults table) {
 * return new DefaultListCellRenderer();
 * }
 * };
 *
 * uiDefaultsTable.put("MyRenderer", cellRendererActiveValue);
 * </pre>
 *
 * @see UIDefaults#get
 */
 public interface ActiveValue {
 /**
 * Creates the value retrieved from the <code>UIDefaults</code> table.
 * The object is created each time it is accessed.
 *
 * @param table a <code>UIDefaults</code> table
 * @return the created <code>Object</code>
 */
 Object createValue(UIDefaults table);
 }

 /**
 * This class provides an implementation of <code>LazyValue</code>
 * 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
 * <code>LazyValue</code>
 * 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 <code>createValue</code> 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 <code>LazyValue</code> which will construct an instance
 * when asked.
 *
 * @param c a <code>String</code> specifying the classname
 * of the instance to be created on demand
 */
 public ProxyLazyValue(String c) {
 this(c, (String)null);
 }
 /**
 * Creates a <code>LazyValue</code> which will construct an instance
 * when asked.
 *
 * @param c a <code>String</code> specifying the classname of
 * the class
 * containing a static method to be called for
 * instance creation
 * @param m a <code>String</code> specifying the static
 * method to be called on class c
 */
 public ProxyLazyValue(String c, String m) {
 this(c, m, null);
 }
 /**
 * Creates a <code>LazyValue</code> which will construct an instance
 * when asked.
 *
 * @param c a <code>String</code> specifying the classname
 * of the instance to be created on demand
 * @param o an array of <code>Objects</code> to be passed as
 * paramaters to the constructor in class c
 */
 public ProxyLazyValue(String c, Object[] o) {
 this(c, null, o);
 }
 /**
 * Creates a <code>LazyValue</code> which will construct an instance
 * when asked.
 *
 * @param c a <code>String</code> specifying the classname
 * of the class
 * containing a static method to be called for
 * instance creation.
 * @param m a <code>String</code> specifying the static method
 * to be called on class c
 * @param o an array of <code>Objects</code> 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 <code>UIDefaults</code> table.
 * The object is created each time it is accessed.
 *
 * @param table a <code>UIDefaults</code> table
 * @return the created <code>Object</code>
 */
 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<Object>() {
 public Object run() {
 try {
 Class<?> c;
 Object cl;
 // See if we should use a separate ClassLoader
 if (table == null || !((cl = table.get("ClassLoader"))
 instanceof ClassLoader)) {
 cl = Thread.currentThread().
 getContextClassLoader();
 if (cl == null) {
 // Fallback to the system class loader.
 cl = ClassLoader.getSystemClassLoader();
 }
 }
 ReflectUtil.checkPackageAccess(className);
 c = Class.forName(className, true, (ClassLoader)cl);
 SwingUtilities2.checkAccess(c.getModifiers());
 if (methodName != null) {
 Class[] types = getClassArray(args);
 Method m = c.getMethod(methodName, types);
 return MethodUtil.invoke(m, c, args);
 } else {
 Class[] types = getClassArray(args);
 Constructor constructor = c.getConstructor(types);
 SwingUtilities2.checkAccess(constructor.getModifiers());
 return constructor.newInstance(args);
 }
 } catch(Exception e) {
 // Ideally we would throw an exception, unfortunately
 // often times there are errors as an initial look and
 // feel is loaded before one can be switched. Perhaps a
 // flag should be added for debugging, so that if true
 // the exception would be thrown.
 }
 return null;
 }
 }, acc);
 }

 /*
 * Coerce the array of class types provided into one which
 * looks the way the Reflection APIs expect. This is done
 * by substituting primitive types for their Object counterparts,
 * and superclasses for subclasses used to add the
 * <code>UIResource</code> tag.
 */
 private Class[] getClassArray(Object[] args) {
 Class[] types = null;
 if (args!=null) {
 types = new Class[args.length];
 for (int i = 0; i< args.length; i++) {
 /* PENDING(ges): At present only the primitive types
 used are handled correctly; this should eventually
 handle all primitive types */
 if (args[i] instanceof java.lang.Integer) {
 types[i]=Integer.TYPE;
 } else if (args[i] instanceof java.lang.Boolean) {
 types[i]=Boolean.TYPE;
 } else if (args[i] instanceof javax.swing.plaf.ColorUIResource) {
 /* PENDING(ges) Currently the Reflection APIs do not
 search superclasses of parameters supplied for
 constructor/method lookup. Since we only have
 one case where this is needed, we substitute
 directly instead of adding a massive amount
 of mechanism for this. Eventually this will
 probably need to handle the general case as well.
 */
 types[i]=java.awt.Color.class;
 } else {
 types[i]=args[i].getClass();
 }
 }
 }
 return types;
 }

 private String printArgs(Object[] array) {
 String s = "{";
 if (array !=null) {
 for (int i = 0 ; i < array.length-1; i++) {
 s = s.concat(array[i] + ",");
 }
 s = s.concat(array[array.length-1] + "}");
 } else {
 s = s.concat("}");
 }
 return s;
 }
 }


 /**
 * <code>LazyInputMap</code> will create a <code>InputMap</code>
 * in its <code>createValue</code>
 * method. The bindings are passed in in the constructor.
 * The bindings are an array with
 * the even number entries being string <code>KeyStrokes</code>
 * (eg "alt SPACE") and
 * the odd number entries being the value to use in the
 * <code>InputMap</code> (and the key in the <code>ActionMap</code>).
 * @since 1.3
 */
 public static class LazyInputMap implements LazyValue {
 /** Key bindings are registered under. */
 private Object[] bindings;

 public LazyInputMap(Object[] bindings) {
 this.bindings = bindings;
 }

 /**
 * Creates an <code>InputMap</code> with the bindings that are
 * passed in.
 *
 * @param table a <code>UIDefaults</code> table
 * @return the <code>InputMap</code>
 */
 public Object createValue(UIDefaults table) {
 if (bindings != null) {
 InputMap km = LookAndFeel.makeInputMap(bindings);
 return km;
 }
 return null;
 }
 }

 /**
 * <code>TextAndMnemonicHashMap</code> stores swing resource strings. Many of strings
 * can have a mnemonic. For example:
 * FileChooser.saveButton.textAndMnemonic=&Save
 * For this case method get returns "Save" for the key "FileChooser.saveButtonText" and
 * mnemonic "S" for the key "FileChooser.saveButtonMnemonic"
 *
 * There are several patterns for the text and mnemonic suffixes which are checked by the
 * <code>TextAndMnemonicHashMap</code> class.
 * Patterns which are converted to the xxx.textAndMnemonic key:
 * (xxxNameText, xxxNameMnemonic)
 * (xxxNameText, xxxMnemonic)
 * (xxx.nameText, xxx.mnemonic)
 * (xxxText, xxxMnemonic)
 *
 * These patterns can have a mnemonic index in format
 * (xxxDisplayedMnemonicIndex)
 *
 * Pattern which is converted to the xxx.titleAndMnemonic key:
 * (xxxTitle, xxxMnemonic)
 *
 */
 private static class TextAndMnemonicHashMap extends HashMap<String, Object> {

 static final String AND_MNEMONIC = "AndMnemonic";
 static final String TITLE_SUFFIX = ".titleAndMnemonic";
 static final String TEXT_SUFFIX = ".textAndMnemonic";

 @Override
 public Object get(Object key) {

 Object value = super.get(key);

 if (value == null) {

 boolean checkTitle = false;

 String stringKey = key.toString();
 String compositeKey = null;

 if (stringKey.endsWith(AND_MNEMONIC)) {
 return null;
 }

 if (stringKey.endsWith(".mnemonic")) {
 compositeKey = composeKey(stringKey, 9, TEXT_SUFFIX);
 } else if (stringKey.endsWith("NameMnemonic")) {
 compositeKey = composeKey(stringKey, 12, TEXT_SUFFIX);
 } else if (stringKey.endsWith("Mnemonic")) {
 compositeKey = composeKey(stringKey, 8, TEXT_SUFFIX);
 checkTitle = true;
 }

 if (compositeKey != null) {
 value = super.get(compositeKey);
 if (value == null && checkTitle) {
 compositeKey = composeKey(stringKey, 8, TITLE_SUFFIX);
 value = super.get(compositeKey);
 }

 return value == null ? null : getMnemonicFromProperty(value.toString());
 }

 if (stringKey.endsWith("NameText")) {
 compositeKey = composeKey(stringKey, 8, TEXT_SUFFIX);
 } else if (stringKey.endsWith(".nameText")) {
 compositeKey = composeKey(stringKey, 9, TEXT_SUFFIX);
 } else if (stringKey.endsWith("Text")) {
 compositeKey = composeKey(stringKey, 4, TEXT_SUFFIX);
 } else if (stringKey.endsWith("Title")) {
 compositeKey = composeKey(stringKey, 5, TITLE_SUFFIX);
 }

 if (compositeKey != null) {
 value = super.get(compositeKey);
 return value == null ? null : getTextFromProperty(value.toString());
 }

 if (stringKey.endsWith("DisplayedMnemonicIndex")) {
 compositeKey = composeKey(stringKey, 22, TEXT_SUFFIX);
 value = super.get(compositeKey);
 if (value == null) {
 compositeKey = composeKey(stringKey, 22, TITLE_SUFFIX);
 value = super.get(compositeKey);
 }
 return value == null ? null : getIndexFromProperty(value.toString());
 }
 }

 return value;
 }

 String composeKey(String key, int reduce, String sufix) {
 return key.substring(0, key.length() - reduce) + sufix;
 }

 String getTextFromProperty(String text) {
 return text.replace("&", "");
 }

 String getMnemonicFromProperty(String text) {
 int index = text.indexOf('&');
 if (0 <= index && index < text.length() - 1) {
 char c = text.charAt(index + 1);
 return Integer.toString((int) Character.toUpperCase(c));
 }
 return null;
 }

 String getIndexFromProperty(String text) {
 int index = text.indexOf('&');
 return (index == -1) ? null : Integer.toString(index);
 }
 }

}