You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1330 lines
48 KiB
1330 lines
48 KiB
/*
|
|
* 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™
|
|
* 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&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);
|
|
}
|
|
}
|
|
|
|
}
|