Home » openjdk-7 » javax » swing » [javadoc | source]

    1   /*
    2    * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   
   26   package javax.swing;
   27   
   28   
   29   import javax.swing.plaf.ComponentUI;
   30   import javax.swing.border;
   31   import javax.swing.event.SwingPropertyChangeSupport;
   32   
   33   import java.lang.reflect;
   34   import java.util.HashMap;
   35   import java.util.Map;
   36   import java.util.Enumeration;
   37   import java.util.Hashtable;
   38   import java.util.ResourceBundle;
   39   import java.util.ResourceBundle.Control;
   40   import java.util.Locale;
   41   import java.util.Vector;
   42   import java.util.MissingResourceException;
   43   import java.awt.Font;
   44   import java.awt.Color;
   45   import java.awt.Insets;
   46   import java.awt.Dimension;
   47   import java.lang.reflect.Method;
   48   import java.beans.PropertyChangeListener;
   49   import java.beans.PropertyChangeEvent;
   50   import java.security.AccessController;
   51   import java.security.AccessControlContext;
   52   import java.security.PrivilegedAction;
   53   
   54   import sun.reflect.misc.MethodUtil;
   55   import sun.reflect.misc.ReflectUtil;
   56   import sun.util.CoreResourceBundleControl;
   57   
   58   /**
   59    * A table of defaults for Swing components.  Applications can set/get
   60    * default values via the <code>UIManager</code>.
   61    * <p>
   62    * <strong>Warning:</strong>
   63    * Serialized objects of this class will not be compatible with
   64    * future Swing releases. The current serialization support is
   65    * appropriate for short term storage or RMI between applications running
   66    * the same version of Swing.  As of 1.4, support for long term storage
   67    * of all JavaBeans<sup><font size="-2">TM</font></sup>
   68    * has been added to the <code>java.beans</code> package.
   69    * Please see {@link java.beans.XMLEncoder}.
   70    *
   71    * @see UIManager
   72    * @author Hans Muller
   73    */
   74   public class UIDefaults extends Hashtable<Object,Object>
   75   {
   76       private static final Object PENDING = "Pending";
   77   
   78       private SwingPropertyChangeSupport changeSupport;
   79   
   80       private Vector<String> resourceBundles;
   81   
   82       private Locale defaultLocale = Locale.getDefault();
   83   
   84       /**
   85        * Maps from a Locale to a cached Map of the ResourceBundle. This is done
   86        * so as to avoid an exception being thrown when a value is asked for.
   87        * Access to this should be done while holding a lock on the
   88        * UIDefaults, eg synchronized(this).
   89        */
   90       private Map<Locale, Map<String, Object>> resourceCache;
   91   
   92       /**
   93        * Creates an empty defaults table.
   94        */
   95       public UIDefaults() {
   96           this(700, .75f);
   97       }
   98   
   99       /**
  100        * Creates an empty defaults table with the specified initial capacity and
  101        * load factor.
  102        *
  103        * @param initialCapacity   the initial capacity of the defaults table
  104        * @param loadFactor        the load factor of the defaults table
  105        * @see java.util.Hashtable
  106        * @since 1.6
  107        */
  108       public UIDefaults(int initialCapacity, float loadFactor) {
  109           super(initialCapacity, loadFactor);
  110           resourceCache = new HashMap<Locale, Map<String, Object>>();
  111       }
  112   
  113   
  114       /**
  115        * Creates a defaults table initialized with the specified
  116        * key/value pairs.  For example:
  117        * <pre>
  118           Object[] uiDefaults = {
  119                "Font", new Font("Dialog", Font.BOLD, 12),
  120               "Color", Color.red,
  121                "five", new Integer(5)
  122           }
  123           UIDefaults myDefaults = new UIDefaults(uiDefaults);
  124        * </pre>
  125        * @param keyValueList  an array of objects containing the key/value
  126        *          pairs
  127        */
  128       public UIDefaults(Object[] keyValueList) {
  129           super(keyValueList.length / 2);
  130           for(int i = 0; i < keyValueList.length; i += 2) {
  131               super.put(keyValueList[i], keyValueList[i + 1]);
  132           }
  133       }
  134   
  135       /**
  136        * Returns the value for key.  If the value is a
  137        * <code>UIDefaults.LazyValue</code> then the real
  138        * value is computed with <code>LazyValue.createValue()</code>,
  139        * the table entry is replaced, and the real value is returned.
  140        * If the value is an <code>UIDefaults.ActiveValue</code>
  141        * the table entry is not replaced - the value is computed
  142        * with <code>ActiveValue.createValue()</code> for each
  143        * <code>get()</code> call.
  144        *
  145        * If the key is not found in the table then it is searched for in the list
  146        * of resource bundles maintained by this object.  The resource bundles are
  147        * searched most recently added first using the locale returned by
  148        * <code>getDefaultLocale</code>.  <code>LazyValues</code> and
  149        * <code>ActiveValues</code> are not supported in the resource bundles.
  150   
  151        *
  152        * @param key the desired key
  153        * @return the value for <code>key</code>
  154        * @see LazyValue
  155        * @see ActiveValue
  156        * @see java.util.Hashtable#get
  157        * @see #getDefaultLocale
  158        * @see #addResourceBundle
  159        * @since 1.4
  160        */
  161       public Object get(Object key) {
  162           Object value = getFromHashtable( key );
  163           return (value != null) ? value : getFromResourceBundle(key, null);
  164       }
  165   
  166       /**
  167        * Looks up up the given key in our Hashtable and resolves LazyValues
  168        * or ActiveValues.
  169        */
  170       private Object getFromHashtable(Object key) {
  171           /* Quickly handle the common case, without grabbing
  172            * a lock.
  173            */
  174           Object value = super.get(key);
  175           if ((value != PENDING) &&
  176               !(value instanceof ActiveValue) &&
  177               !(value instanceof LazyValue)) {
  178               return value;
  179           }
  180   
  181           /* If the LazyValue for key is being constructed by another
  182            * thread then wait and then return the new value, otherwise drop
  183            * the lock and construct the ActiveValue or the LazyValue.
  184            * We use the special value PENDING to mark LazyValues that
  185            * are being constructed.
  186            */
  187           synchronized(this) {
  188               value = super.get(key);
  189               if (value == PENDING) {
  190                   do {
  191                       try {
  192                           this.wait();
  193                       }
  194                       catch (InterruptedException e) {
  195                       }
  196                       value = super.get(key);
  197                   }
  198                   while(value == PENDING);
  199                   return value;
  200               }
  201               else if (value instanceof LazyValue) {
  202                   super.put(key, PENDING);
  203               }
  204               else if (!(value instanceof ActiveValue)) {
  205                   return value;
  206               }
  207           }
  208   
  209           /* At this point we know that the value of key was
  210            * a LazyValue or an ActiveValue.
  211            */
  212           if (value instanceof LazyValue) {
  213               try {
  214                   /* If an exception is thrown we'll just put the LazyValue
  215                    * back in the table.
  216                    */
  217                   value = ((LazyValue)value).createValue(this);
  218               }
  219               finally {
  220                   synchronized(this) {
  221                       if (value == null) {
  222                           super.remove(key);
  223                       }
  224                       else {
  225                           super.put(key, value);
  226                       }
  227                       this.notifyAll();
  228                   }
  229               }
  230           }
  231           else {
  232               value = ((ActiveValue)value).createValue(this);
  233           }
  234   
  235           return value;
  236       }
  237   
  238   
  239       /**
  240        * Returns the value for key associated with the given locale.
  241        * If the value is a <code>UIDefaults.LazyValue</code> then the real
  242        * value is computed with <code>LazyValue.createValue()</code>,
  243        * the table entry is replaced, and the real value is returned.
  244        * If the value is an <code>UIDefaults.ActiveValue</code>
  245        * the table entry is not replaced - the value is computed
  246        * with <code>ActiveValue.createValue()</code> for each
  247        * <code>get()</code> call.
  248        *
  249        * If the key is not found in the table then it is searched for in the list
  250        * of resource bundles maintained by this object.  The resource bundles are
  251        * searched most recently added first using the given locale.
  252        * <code>LazyValues</code> and <code>ActiveValues</code> are not supported
  253        * in the resource bundles.
  254        *
  255        * @param key the desired key
  256        * @param l the desired <code>locale</code>
  257        * @return the value for <code>key</code>
  258        * @see LazyValue
  259        * @see ActiveValue
  260        * @see java.util.Hashtable#get
  261        * @see #addResourceBundle
  262        * @since 1.4
  263        */
  264       public Object get(Object key, Locale l) {
  265           Object value = getFromHashtable( key );
  266           return (value != null) ? value : getFromResourceBundle(key, l);
  267       }
  268   
  269       /**
  270        * Looks up given key in our resource bundles.
  271        */
  272       private Object getFromResourceBundle(Object key, Locale l) {
  273   
  274           if( resourceBundles == null ||
  275               resourceBundles.isEmpty() ||
  276               !(key instanceof String) ) {
  277               return null;
  278           }
  279   
  280           // A null locale means use the default locale.
  281           if( l == null ) {
  282               if( defaultLocale == null )
  283                   return null;
  284               else
  285                   l = defaultLocale;
  286           }
  287   
  288           synchronized(this) {
  289               return getResourceCache(l).get(key);
  290           }
  291       }
  292   
  293       /**
  294        * Returns a Map of the known resources for the given locale.
  295        */
  296       private Map<String, Object> getResourceCache(Locale l) {
  297           Map<String, Object> values = resourceCache.get(l);
  298   
  299           if (values == null) {
  300               values = new HashMap<String, Object>();
  301               for (int i=resourceBundles.size()-1; i >= 0; i--) {
  302                   String bundleName = resourceBundles.get(i);
  303                   try {
  304                       Control c = CoreResourceBundleControl.getRBControlInstance(bundleName);
  305                       ResourceBundle b;
  306                       if (c != null) {
  307                           b = ResourceBundle.getBundle(bundleName, l, c);
  308                       } else {
  309                           b = ResourceBundle.getBundle(bundleName, l);
  310                       }
  311                       Enumeration keys = b.getKeys();
  312   
  313                       while (keys.hasMoreElements()) {
  314                           String key = (String)keys.nextElement();
  315   
  316                           if (values.get(key) == null) {
  317                               Object value = b.getObject(key);
  318   
  319                               values.put(key, value);
  320                           }
  321                       }
  322                   } catch( MissingResourceException mre ) {
  323                       // Keep looking
  324                   }
  325               }
  326               resourceCache.put(l, values);
  327           }
  328           return values;
  329       }
  330   
  331       /**
  332        * Sets the value of <code>key</code> to <code>value</code> for all locales.
  333        * If <code>key</code> is a string and the new value isn't
  334        * equal to the old one, fire a <code>PropertyChangeEvent</code>.
  335        * If value is <code>null</code>, the key is removed from the table.
  336        *
  337        * @param key    the unique <code>Object</code> who's value will be used
  338        *          to retrieve the data value associated with it
  339        * @param value  the new <code>Object</code> to store as data under
  340        *          that key
  341        * @return the previous <code>Object</code> value, or <code>null</code>
  342        * @see #putDefaults
  343        * @see java.util.Hashtable#put
  344        */
  345       public Object put(Object key, Object value) {
  346           Object oldValue = (value == null) ? super.remove(key) : super.put(key, value);
  347           if (key instanceof String) {
  348               firePropertyChange((String)key, oldValue, value);
  349           }
  350           return oldValue;
  351       }
  352   
  353   
  354       /**
  355        * Puts all of the key/value pairs in the database and
  356        * unconditionally generates one <code>PropertyChangeEvent</code>.
  357        * The events oldValue and newValue will be <code>null</code> and its
  358        * <code>propertyName</code> will be "UIDefaults".  The key/value pairs are
  359        * added for all locales.
  360        *
  361        * @param keyValueList  an array of key/value pairs
  362        * @see #put
  363        * @see java.util.Hashtable#put
  364        */
  365       public void putDefaults(Object[] keyValueList) {
  366           for(int i = 0, max = keyValueList.length; i < max; i += 2) {
  367               Object value = keyValueList[i + 1];
  368               if (value == null) {
  369                   super.remove(keyValueList[i]);
  370               }
  371               else {
  372                   super.put(keyValueList[i], value);
  373               }
  374           }
  375           firePropertyChange("UIDefaults", null, null);
  376       }
  377   
  378   
  379       /**
  380        * If the value of <code>key</code> is a <code>Font</code> return it,
  381        * otherwise return <code>null</code>.
  382        * @param key the desired key
  383        * @return if the value for <code>key</code> is a <code>Font</code>,
  384        *          return the <code>Font</code> object; otherwise return
  385        *          <code>null</code>
  386        */
  387       public Font getFont(Object key) {
  388           Object value = get(key);
  389           return (value instanceof Font) ? (Font)value : null;
  390       }
  391   
  392   
  393       /**
  394        * If the value of <code>key</code> for the given <code>Locale</code>
  395        * is a <code>Font</code> return it, otherwise return <code>null</code>.
  396        * @param key the desired key
  397        * @param l the desired locale
  398        * @return if the value for <code>key</code> and <code>Locale</code>
  399        *          is a <code>Font</code>,
  400        *          return the <code>Font</code> object; otherwise return
  401        *          <code>null</code>
  402        * @since 1.4
  403        */
  404       public Font getFont(Object key, Locale l) {
  405           Object value = get(key,l);
  406           return (value instanceof Font) ? (Font)value : null;
  407       }
  408   
  409       /**
  410        * If the value of <code>key</code> is a <code>Color</code> return it,
  411        * otherwise return <code>null</code>.
  412        * @param key the desired key
  413        * @return if the value for <code>key</code> is a <code>Color</code>,
  414        *          return the <code>Color</code> object; otherwise return
  415        *          <code>null</code>
  416        */
  417       public Color getColor(Object key) {
  418           Object value = get(key);
  419           return (value instanceof Color) ? (Color)value : null;
  420       }
  421   
  422   
  423       /**
  424        * If the value of <code>key</code> for the given <code>Locale</code>
  425        * is a <code>Color</code> return it, otherwise return <code>null</code>.
  426        * @param key the desired key
  427        * @param l the desired locale
  428        * @return if the value for <code>key</code> and <code>Locale</code>
  429        *          is a <code>Color</code>,
  430        *          return the <code>Color</code> object; otherwise return
  431        *          <code>null</code>
  432        * @since 1.4
  433        */
  434       public Color getColor(Object key, Locale l) {
  435           Object value = get(key,l);
  436           return (value instanceof Color) ? (Color)value : null;
  437       }
  438   
  439   
  440       /**
  441        * If the value of <code>key</code> is an <code>Icon</code> return it,
  442        * otherwise return <code>null</code>.
  443        * @param key the desired key
  444        * @return if the value for <code>key</code> is an <code>Icon</code>,
  445        *          return the <code>Icon</code> object; otherwise return
  446        *          <code>null</code>
  447        */
  448       public Icon getIcon(Object key) {
  449           Object value = get(key);
  450           return (value instanceof Icon) ? (Icon)value : null;
  451       }
  452   
  453   
  454       /**
  455        * If the value of <code>key</code> for the given <code>Locale</code>
  456        * is an <code>Icon</code> return it, otherwise return <code>null</code>.
  457        * @param key the desired key
  458        * @param l the desired locale
  459        * @return if the value for <code>key</code> and <code>Locale</code>
  460        *          is an <code>Icon</code>,
  461        *          return the <code>Icon</code> object; otherwise return
  462        *          <code>null</code>
  463        * @since 1.4
  464        */
  465       public Icon getIcon(Object key, Locale l) {
  466           Object value = get(key,l);
  467           return (value instanceof Icon) ? (Icon)value : null;
  468       }
  469   
  470   
  471       /**
  472        * If the value of <code>key</code> is a <code>Border</code> return it,
  473        * otherwise return <code>null</code>.
  474        * @param key the desired key
  475        * @return if the value for <code>key</code> is a <code>Border</code>,
  476        *          return the <code>Border</code> object; otherwise return
  477        *          <code>null</code>
  478        */
  479       public Border getBorder(Object key) {
  480           Object value = get(key);
  481           return (value instanceof Border) ? (Border)value : null;
  482       }
  483   
  484   
  485       /**
  486        * If the value of <code>key</code> for the given <code>Locale</code>
  487        * is a <code>Border</code> return it, otherwise return <code>null</code>.
  488        * @param key the desired key
  489        * @param l the desired locale
  490        * @return if the value for <code>key</code> and <code>Locale</code>
  491        *          is a <code>Border</code>,
  492        *          return the <code>Border</code> object; otherwise return
  493        *          <code>null</code>
  494        * @since 1.4
  495        */
  496       public Border getBorder(Object key, Locale l)  {
  497           Object value = get(key,l);
  498           return (value instanceof Border) ? (Border)value : null;
  499       }
  500   
  501   
  502       /**
  503        * If the value of <code>key</code> is a <code>String</code> return it,
  504        * otherwise return <code>null</code>.
  505        * @param key the desired key
  506        * @return if the value for <code>key</code> is a <code>String</code>,
  507        *          return the <code>String</code> object; otherwise return
  508        *          <code>null</code>
  509        */
  510       public String getString(Object key) {
  511           Object value = get(key);
  512           return (value instanceof String) ? (String)value : null;
  513       }
  514   
  515       /**
  516        * If the value of <code>key</code> for the given <code>Locale</code>
  517        * is a <code>String</code> return it, otherwise return <code>null</code>.
  518        * @param key the desired key
  519        * @param l the desired <code>Locale</code>
  520        * @return if the value for <code>key</code> for the given
  521        *          <code>Locale</code> is a <code>String</code>,
  522        *          return the <code>String</code> object; otherwise return
  523        *          <code>null</code>
  524        * @since 1.4
  525        */
  526       public String getString(Object key, Locale l) {
  527           Object value = get(key,l);
  528           return (value instanceof String) ? (String)value : null;
  529       }
  530   
  531       /**
  532        * If the value of <code>key</code> is an <code>Integer</code> return its
  533        * integer value, otherwise return 0.
  534        * @param key the desired key
  535        * @return if the value for <code>key</code> is an <code>Integer</code>,
  536        *          return its value, otherwise return 0
  537        */
  538       public int getInt(Object key) {
  539           Object value = get(key);
  540           return (value instanceof Integer) ? ((Integer)value).intValue() : 0;
  541       }
  542   
  543   
  544       /**
  545        * If the value of <code>key</code> for the given <code>Locale</code>
  546        * is an <code>Integer</code> return its integer value, otherwise return 0.
  547        * @param key the desired key
  548        * @param l the desired locale
  549        * @return if the value for <code>key</code> and <code>Locale</code>
  550        *          is an <code>Integer</code>,
  551        *          return its value, otherwise return 0
  552        * @since 1.4
  553        */
  554       public int getInt(Object key, Locale l) {
  555           Object value = get(key,l);
  556           return (value instanceof Integer) ? ((Integer)value).intValue() : 0;
  557       }
  558   
  559   
  560       /**
  561        * If the value of <code>key</code> is boolean, return the
  562        * boolean value, otherwise return false.
  563        *
  564        * @param key an <code>Object</code> specifying the key for the desired boolean value
  565        * @return if the value of <code>key</code> is boolean, return the
  566        *         boolean value, otherwise return false.
  567        * @since 1.4
  568        */
  569       public boolean getBoolean(Object key) {
  570           Object value = get(key);
  571           return (value instanceof Boolean) ? ((Boolean)value).booleanValue() : false;
  572       }
  573   
  574   
  575       /**
  576        * If the value of <code>key</code> for the given <code>Locale</code>
  577        * is boolean, return the boolean value, otherwise return false.
  578        *
  579        * @param key an <code>Object</code> specifying the key for the desired boolean value
  580        * @param l the desired locale
  581        * @return if the value for <code>key</code> and <code>Locale</code>
  582        *         is boolean, return the
  583        *         boolean value, otherwise return false.
  584        * @since 1.4
  585        */
  586       public boolean getBoolean(Object key, Locale l) {
  587           Object value = get(key,l);
  588           return (value instanceof Boolean) ? ((Boolean)value).booleanValue() : false;
  589       }
  590   
  591   
  592       /**
  593        * If the value of <code>key</code> is an <code>Insets</code> return it,
  594        * otherwise return <code>null</code>.
  595        * @param key the desired key
  596        * @return if the value for <code>key</code> is an <code>Insets</code>,
  597        *          return the <code>Insets</code> object; otherwise return
  598        *          <code>null</code>
  599        */
  600       public Insets getInsets(Object key) {
  601           Object value = get(key);
  602           return (value instanceof Insets) ? (Insets)value : null;
  603       }
  604   
  605   
  606       /**
  607        * If the value of <code>key</code> for the given <code>Locale</code>
  608        * is an <code>Insets</code> return it, otherwise return <code>null</code>.
  609        * @param key the desired key
  610        * @param l the desired locale
  611        * @return if the value for <code>key</code> and <code>Locale</code>
  612        *          is an <code>Insets</code>,
  613        *          return the <code>Insets</code> object; otherwise return
  614        *          <code>null</code>
  615        * @since 1.4
  616        */
  617       public Insets getInsets(Object key, Locale l) {
  618           Object value = get(key,l);
  619           return (value instanceof Insets) ? (Insets)value : null;
  620       }
  621   
  622   
  623       /**
  624        * If the value of <code>key</code> is a <code>Dimension</code> return it,
  625        * otherwise return <code>null</code>.
  626        * @param key the desired key
  627        * @return if the value for <code>key</code> is a <code>Dimension</code>,
  628        *          return the <code>Dimension</code> object; otherwise return
  629        *          <code>null</code>
  630        */
  631       public Dimension getDimension(Object key) {
  632           Object value = get(key);
  633           return (value instanceof Dimension) ? (Dimension)value : null;
  634       }
  635   
  636   
  637       /**
  638        * If the value of <code>key</code> for the given <code>Locale</code>
  639        * is a <code>Dimension</code> return it, otherwise return <code>null</code>.
  640        * @param key the desired key
  641        * @param l the desired locale
  642        * @return if the value for <code>key</code> and <code>Locale</code>
  643        *          is a <code>Dimension</code>,
  644        *          return the <code>Dimension</code> object; otherwise return
  645        *          <code>null</code>
  646        * @since 1.4
  647        */
  648       public Dimension getDimension(Object key, Locale l) {
  649           Object value = get(key,l);
  650           return (value instanceof Dimension) ? (Dimension)value : null;
  651       }
  652   
  653   
  654       /**
  655        * The value of <code>get(uidClassID)</code> must be the
  656        * <code>String</code> name of a
  657        * class that implements the corresponding <code>ComponentUI</code>
  658        * class.  If the class hasn't been loaded before, this method looks
  659        * up the class with <code>uiClassLoader.loadClass()</code> if a non
  660        * <code>null</code>
  661        * class loader is provided, <code>classForName()</code> otherwise.
  662        * <p>
  663        * If a mapping for <code>uiClassID</code> exists or if the specified
  664        * class can't be found, return <code>null</code>.
  665        * <p>
  666        * This method is used by <code>getUI</code>, it's usually
  667        * not necessary to call it directly.
  668        *
  669        * @param uiClassID  a string containing the class ID
  670        * @param uiClassLoader the object which will load the class
  671        * @return the value of <code>Class.forName(get(uidClassID))</code>
  672        * @see #getUI
  673        */
  674       public Class<? extends ComponentUI>
  675           getUIClass(String uiClassID, ClassLoader uiClassLoader)
  676       {
  677           try {
  678               String className = (String)get(uiClassID);
  679               if (className != null) {
  680                   Class cls = (Class)get(className);
  681                   if (cls == null) {
  682                       if (uiClassLoader == null) {
  683                           cls = SwingUtilities.loadSystemClass(className);
  684                       }
  685                       else {
  686                           cls = uiClassLoader.loadClass(className);
  687                       }
  688                       if (cls != null) {
  689                           // Save lookup for future use, as forName is slow.
  690                           put(className, cls);
  691                       }
  692                   }
  693                   return cls;
  694               }
  695           }
  696           catch (ClassNotFoundException e) {
  697               return null;
  698           }
  699           catch (ClassCastException e) {
  700               return null;
  701           }
  702           return null;
  703       }
  704   
  705   
  706       /**
  707        * Returns the L&F class that renders this component.
  708        *
  709        * @param uiClassID a string containing the class ID
  710        * @return the Class object returned by
  711        *          <code>getUIClass(uiClassID, null)</code>
  712        */
  713       public Class<? extends ComponentUI> getUIClass(String uiClassID) {
  714           return getUIClass(uiClassID, null);
  715       }
  716   
  717   
  718       /**
  719        * If <code>getUI()</code> fails for any reason,
  720        * it calls this method before returning <code>null</code>.
  721        * Subclasses may choose to do more or less here.
  722        *
  723        * @param msg message string to print
  724        * @see #getUI
  725        */
  726       protected void getUIError(String msg) {
  727           System.err.println("UIDefaults.getUI() failed: " + msg);
  728           try {
  729               throw new Error();
  730           }
  731           catch (Throwable e) {
  732               e.printStackTrace();
  733           }
  734       }
  735   
  736       /**
  737        * Creates an <code>ComponentUI</code> implementation for the
  738        * specified component.  In other words create the look
  739        * and feel specific delegate object for <code>target</code>.
  740        * This is done in two steps:
  741        * <ul>
  742        * <li> Look up the name of the <code>ComponentUI</code> implementation
  743        * class under the value returned by <code>target.getUIClassID()</code>.
  744        * <li> Use the implementation classes static <code>createUI()</code>
  745        * method to construct a look and feel delegate.
  746        * </ul>
  747        * @param target  the <code>JComponent</code> which needs a UI
  748        * @return the <code>ComponentUI</code> object
  749        */
  750       public ComponentUI getUI(JComponent target) {
  751   
  752           Object cl = get("ClassLoader");
  753           ClassLoader uiClassLoader =
  754               (cl != null) ? (ClassLoader)cl : target.getClass().getClassLoader();
  755           Class<? extends ComponentUI> uiClass = getUIClass(target.getUIClassID(), uiClassLoader);
  756           Object uiObject = null;
  757   
  758           if (uiClass == null) {
  759               getUIError("no ComponentUI class for: " + target);
  760           }
  761           else {
  762               try {
  763                   Method m = (Method)get(uiClass);
  764                   if (m == null) {
  765                       m = uiClass.getMethod("createUI", new Class[]{JComponent.class});
  766                       put(uiClass, m);
  767                   }
  768                   uiObject = MethodUtil.invoke(m, null, new Object[]{target});
  769               }
  770               catch (NoSuchMethodException e) {
  771                   getUIError("static createUI() method not found in " + uiClass);
  772               }
  773               catch (Exception e) {
  774                   getUIError("createUI() failed for " + target + " " + e);
  775               }
  776           }
  777   
  778           return (ComponentUI)uiObject;
  779       }
  780   
  781       /**
  782        * Adds a <code>PropertyChangeListener</code> to the listener list.
  783        * The listener is registered for all properties.
  784        * <p>
  785        * A <code>PropertyChangeEvent</code> will get fired whenever a default
  786        * is changed.
  787        *
  788        * @param listener  the <code>PropertyChangeListener</code> to be added
  789        * @see java.beans.PropertyChangeSupport
  790        */
  791       public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
  792           if (changeSupport == null) {
  793               changeSupport = new SwingPropertyChangeSupport(this);
  794           }
  795           changeSupport.addPropertyChangeListener(listener);
  796       }
  797   
  798   
  799       /**
  800        * Removes a <code>PropertyChangeListener</code> from the listener list.
  801        * This removes a <code>PropertyChangeListener</code> that was registered
  802        * for all properties.
  803        *
  804        * @param listener  the <code>PropertyChangeListener</code> to be removed
  805        * @see java.beans.PropertyChangeSupport
  806        */
  807       public synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
  808           if (changeSupport != null) {
  809               changeSupport.removePropertyChangeListener(listener);
  810           }
  811       }
  812   
  813   
  814       /**
  815        * Returns an array of all the <code>PropertyChangeListener</code>s added
  816        * to this UIDefaults with addPropertyChangeListener().
  817        *
  818        * @return all of the <code>PropertyChangeListener</code>s added or an empty
  819        *         array if no listeners have been added
  820        * @since 1.4
  821        */
  822       public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
  823           if (changeSupport == null) {
  824               return new PropertyChangeListener[0];
  825           }
  826           return changeSupport.getPropertyChangeListeners();
  827       }
  828   
  829   
  830       /**
  831        * Support for reporting bound property changes.  If oldValue and
  832        * newValue are not equal and the <code>PropertyChangeEvent</code>x
  833        * listener list isn't empty, then fire a
  834        * <code>PropertyChange</code> event to each listener.
  835        *
  836        * @param propertyName  the programmatic name of the property
  837        *          that was changed
  838        * @param oldValue  the old value of the property
  839        * @param newValue  the new value of the property
  840        * @see java.beans.PropertyChangeSupport
  841        */
  842       protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
  843           if (changeSupport != null) {
  844               changeSupport.firePropertyChange(propertyName, oldValue, newValue);
  845           }
  846       }
  847   
  848   
  849       /**
  850        * Adds a resource bundle to the list of resource bundles that are
  851        * searched for localized values.  Resource bundles are searched in the
  852        * reverse order they were added.  In other words, the most recently added
  853        * bundle is searched first.
  854        *
  855        * @param bundleName  the base name of the resource bundle to be added
  856        * @see java.util.ResourceBundle
  857        * @see #removeResourceBundle
  858        * @since 1.4
  859        */
  860       public synchronized void addResourceBundle( String bundleName ) {
  861           if( bundleName == null ) {
  862               return;
  863           }
  864           if( resourceBundles == null ) {
  865               resourceBundles = new Vector<String>(5);
  866           }
  867           if (!resourceBundles.contains(bundleName)) {
  868               resourceBundles.add( bundleName );
  869               resourceCache.clear();
  870           }
  871       }
  872   
  873   
  874       /**
  875        * Removes a resource bundle from the list of resource bundles that are
  876        * searched for localized defaults.
  877        *
  878        * @param bundleName  the base name of the resource bundle to be removed
  879        * @see java.util.ResourceBundle
  880        * @see #addResourceBundle
  881        * @since 1.4
  882        */
  883       public synchronized void removeResourceBundle( String bundleName ) {
  884           if( resourceBundles != null ) {
  885               resourceBundles.remove( bundleName );
  886           }
  887           resourceCache.clear();
  888       }
  889   
  890       /**
  891        * Sets the default locale.  The default locale is used in retrieving
  892        * localized values via <code>get</code> methods that do not take a
  893        * locale argument.  As of release 1.4, Swing UI objects should retrieve
  894        * localized values using the locale of their component rather than the
  895        * default locale.  The default locale exists to provide compatibility with
  896        * pre 1.4 behaviour.
  897        *
  898        * @param l the new default locale
  899        * @see #getDefaultLocale
  900        * @see #get(Object)
  901        * @see #get(Object,Locale)
  902        * @since 1.4
  903        */
  904       public void setDefaultLocale( Locale l ) {
  905           defaultLocale = l;
  906       }
  907   
  908       /**
  909        * Returns the default locale.  The default locale is used in retrieving
  910        * localized values via <code>get</code> methods that do not take a
  911        * locale argument.  As of release 1.4, Swing UI objects should retrieve
  912        * localized values using the locale of their component rather than the
  913        * default locale.  The default locale exists to provide compatibility with
  914        * pre 1.4 behaviour.
  915        *
  916        * @return the default locale
  917        * @see #setDefaultLocale
  918        * @see #get(Object)
  919        * @see #get(Object,Locale)
  920        * @since 1.4
  921        */
  922       public Locale getDefaultLocale() {
  923           return defaultLocale;
  924       }
  925   
  926       /**
  927        * This class enables one to store an entry in the defaults
  928        * table that isn't constructed until the first time it's
  929        * looked up with one of the <code>getXXX(key)</code> methods.
  930        * Lazy values are useful for defaults that are expensive
  931        * to construct or are seldom retrieved.  The first time
  932        * a <code>LazyValue</code> is retrieved its "real value" is computed
  933        * by calling <code>LazyValue.createValue()</code> and the real
  934        * value is used to replace the <code>LazyValue</code> in the
  935        * <code>UIDefaults</code>
  936        * table.  Subsequent lookups for the same key return
  937        * the real value.  Here's an example of a <code>LazyValue</code>
  938        * that constructs a <code>Border</code>:
  939        * <pre>
  940        *  Object borderLazyValue = new UIDefaults.LazyValue() {
  941        *      public Object createValue(UIDefaults table) {
  942        *          return new BorderFactory.createLoweredBevelBorder();
  943        *      }
  944        *  };
  945        *
  946        *  uiDefaultsTable.put("MyBorder", borderLazyValue);
  947        * </pre>
  948        *
  949        * @see UIDefaults#get
  950        */
  951       public interface LazyValue {
  952           /**
  953            * Creates the actual value retrieved from the <code>UIDefaults</code>
  954            * table. When an object that implements this interface is
  955            * retrieved from the table, this method is used to create
  956            * the real value, which is then stored in the table and
  957            * returned to the calling method.
  958            *
  959            * @param table  a <code>UIDefaults</code> table
  960            * @return the created <code>Object</code>
  961            */
  962           Object createValue(UIDefaults table);
  963       }
  964   
  965   
  966       /**
  967        * This class enables one to store an entry in the defaults
  968        * table that's constructed each time it's looked up with one of
  969        * the <code>getXXX(key)</code> methods. Here's an example of
  970        * an <code>ActiveValue</code> that constructs a
  971        * <code>DefaultListCellRenderer</code>:
  972        * <pre>
  973        *  Object cellRendererActiveValue = new UIDefaults.ActiveValue() {
  974        *      public Object createValue(UIDefaults table) {
  975        *          return new DefaultListCellRenderer();
  976        *      }
  977        *  };
  978        *
  979        *  uiDefaultsTable.put("MyRenderer", cellRendererActiveValue);
  980        * </pre>
  981        *
  982        * @see UIDefaults#get
  983        */
  984       public interface ActiveValue {
  985           /**
  986            * Creates the value retrieved from the <code>UIDefaults</code> table.
  987            * The object is created each time it is accessed.
  988            *
  989            * @param table  a <code>UIDefaults</code> table
  990            * @return the created <code>Object</code>
  991            */
  992           Object createValue(UIDefaults table);
  993       }
  994   
  995       /**
  996        * This class provides an implementation of <code>LazyValue</code>
  997        * which can be
  998        * used to delay loading of the Class for the instance to be created.
  999        * It also avoids creation of an anonymous inner class for the
 1000        * <code>LazyValue</code>
 1001        * subclass.  Both of these improve performance at the time that a
 1002        * a Look and Feel is loaded, at the cost of a slight performance
 1003        * reduction the first time <code>createValue</code> is called
 1004        * (since Reflection APIs are used).
 1005        * @since 1.3
 1006        */
 1007       public static class ProxyLazyValue implements LazyValue {
 1008           private AccessControlContext acc;
 1009           private String className;
 1010           private String methodName;
 1011           private Object[] args;
 1012   
 1013           /**
 1014            * Creates a <code>LazyValue</code> which will construct an instance
 1015            * when asked.
 1016            *
 1017            * @param c    a <code>String</code> specifying the classname
 1018            *             of the instance to be created on demand
 1019            */
 1020           public ProxyLazyValue(String c) {
 1021               this(c, (String)null);
 1022           }
 1023           /**
 1024            * Creates a <code>LazyValue</code> which will construct an instance
 1025            * when asked.
 1026            *
 1027            * @param c    a <code>String</code> specifying the classname of
 1028            *              the class
 1029            *              containing a static method to be called for
 1030            *              instance creation
 1031            * @param m    a <code>String</code> specifying the static
 1032            *              method to be called on class c
 1033            */
 1034           public ProxyLazyValue(String c, String m) {
 1035               this(c, m, null);
 1036           }
 1037           /**
 1038            * Creates a <code>LazyValue</code> which will construct an instance
 1039            * when asked.
 1040            *
 1041            * @param c    a <code>String</code> specifying the classname
 1042            *              of the instance to be created on demand
 1043            * @param o    an array of <code>Objects</code> to be passed as
 1044            *              paramaters to the constructor in class c
 1045            */
 1046           public ProxyLazyValue(String c, Object[] o) {
 1047               this(c, null, o);
 1048           }
 1049           /**
 1050            * Creates a <code>LazyValue</code> which will construct an instance
 1051            * when asked.
 1052            *
 1053            * @param c    a <code>String</code> specifying the classname
 1054            *              of the class
 1055            *              containing a static method to be called for
 1056            *              instance creation.
 1057            * @param m    a <code>String</code> specifying the static method
 1058            *              to be called on class c
 1059            * @param o    an array of <code>Objects</code> to be passed as
 1060            *              paramaters to the static method in class c
 1061            */
 1062           public ProxyLazyValue(String c, String m, Object[] o) {
 1063               acc = AccessController.getContext();
 1064               className = c;
 1065               methodName = m;
 1066               if (o != null) {
 1067                   args = o.clone();
 1068               }
 1069           }
 1070   
 1071           /**
 1072            * Creates the value retrieved from the <code>UIDefaults</code> table.
 1073            * The object is created each time it is accessed.
 1074            *
 1075            * @param table  a <code>UIDefaults</code> table
 1076            * @return the created <code>Object</code>
 1077            */
 1078           public Object createValue(final UIDefaults table) {
 1079               // In order to pick up the security policy in effect at the
 1080               // time of creation we use a doPrivileged with the
 1081               // AccessControlContext that was in place when this was created.
 1082               if (acc == null && System.getSecurityManager() != null) {
 1083                   throw new SecurityException("null AccessControlContext");
 1084               }
 1085               return AccessController.doPrivileged(new PrivilegedAction<Object>() {
 1086                   public Object run() {
 1087                       try {
 1088                           Class<?> c;
 1089                           Object cl;
 1090                           // See if we should use a separate ClassLoader
 1091                           if (table == null || !((cl = table.get("ClassLoader"))
 1092                                                  instanceof ClassLoader)) {
 1093                               cl = Thread.currentThread().
 1094                                           getContextClassLoader();
 1095                               if (cl == null) {
 1096                                   // Fallback to the system class loader.
 1097                                   cl = ClassLoader.getSystemClassLoader();
 1098                               }
 1099                           }
 1100                           ReflectUtil.checkPackageAccess(className);
 1101                           c = Class.forName(className, true, (ClassLoader)cl);
 1102                           checkAccess(c.getModifiers());
 1103                           if (methodName != null) {
 1104                               Class[] types = getClassArray(args);
 1105                               Method m = c.getMethod(methodName, types);
 1106                               return MethodUtil.invoke(m, c, args);
 1107                           } else {
 1108                               Class[] types = getClassArray(args);
 1109                               Constructor constructor = c.getConstructor(types);
 1110                               checkAccess(constructor.getModifiers());
 1111                               return constructor.newInstance(args);
 1112                           }
 1113                       } catch(Exception e) {
 1114                           // Ideally we would throw an exception, unfortunately
 1115                           // often times there are errors as an initial look and
 1116                           // feel is loaded before one can be switched. Perhaps a
 1117                           // flag should be added for debugging, so that if true
 1118                           // the exception would be thrown.
 1119                       }
 1120                       return null;
 1121                   }
 1122               }, acc);
 1123           }
 1124   
 1125           private void checkAccess(int modifiers) {
 1126               if(System.getSecurityManager() != null &&
 1127                       !Modifier.isPublic(modifiers)) {
 1128                   throw new SecurityException("Resource is not accessible");
 1129               }
 1130           }
 1131   
 1132           /*
 1133            * Coerce the array of class types provided into one which
 1134            * looks the way the Reflection APIs expect.  This is done
 1135            * by substituting primitive types for their Object counterparts,
 1136            * and superclasses for subclasses used to add the
 1137            * <code>UIResource</code> tag.
 1138            */
 1139           private Class[] getClassArray(Object[] args) {
 1140               Class[] types = null;
 1141               if (args!=null) {
 1142                   types = new Class[args.length];
 1143                   for (int i = 0; i< args.length; i++) {
 1144                       /* PENDING(ges): At present only the primitive types
 1145                          used are handled correctly; this should eventually
 1146                          handle all primitive types */
 1147                       if (args[i] instanceof java.lang.Integer) {
 1148                           types[i]=Integer.TYPE;
 1149                       } else if (args[i] instanceof java.lang.Boolean) {
 1150                           types[i]=Boolean.TYPE;
 1151                       } else if (args[i] instanceof javax.swing.plaf.ColorUIResource) {
 1152                           /* PENDING(ges) Currently the Reflection APIs do not
 1153                              search superclasses of parameters supplied for
 1154                              constructor/method lookup.  Since we only have
 1155                              one case where this is needed, we substitute
 1156                              directly instead of adding a massive amount
 1157                              of mechanism for this.  Eventually this will
 1158                              probably need to handle the general case as well.
 1159                              */
 1160                           types[i]=java.awt.Color.class;
 1161                       } else {
 1162                           types[i]=args[i].getClass();
 1163                       }
 1164                   }
 1165               }
 1166               return types;
 1167           }
 1168   
 1169           private String printArgs(Object[] array) {
 1170               String s = "{";
 1171               if (array !=null) {
 1172                   for (int i = 0 ; i < array.length-1; i++) {
 1173                       s = s.concat(array[i] + ",");
 1174                   }
 1175                   s = s.concat(array[array.length-1] + "}");
 1176               } else {
 1177                   s = s.concat("}");
 1178               }
 1179               return s;
 1180           }
 1181       }
 1182   
 1183   
 1184       /**
 1185        * <code>LazyInputMap</code> will create a <code>InputMap</code>
 1186        * in its <code>createValue</code>
 1187        * method. The bindings are passed in in the constructor.
 1188        * The bindings are an array with
 1189        * the even number entries being string <code>KeyStrokes</code>
 1190        * (eg "alt SPACE") and
 1191        * the odd number entries being the value to use in the
 1192        * <code>InputMap</code> (and the key in the <code>ActionMap</code>).
 1193        * @since 1.3
 1194        */
 1195       public static class LazyInputMap implements LazyValue {
 1196           /** Key bindings are registered under. */
 1197           private Object[] bindings;
 1198   
 1199           public LazyInputMap(Object[] bindings) {
 1200               this.bindings = bindings;
 1201           }
 1202   
 1203           /**
 1204            * Creates an <code>InputMap</code> with the bindings that are
 1205            * passed in.
 1206            *
 1207            * @param table a <code>UIDefaults</code> table
 1208            * @return the <code>InputMap</code>
 1209            */
 1210           public Object createValue(UIDefaults table) {
 1211               if (bindings != null) {
 1212                   InputMap km = LookAndFeel.makeInputMap(bindings);
 1213                   return km;
 1214               }
 1215               return null;
 1216           }
 1217       }
 1218   }

Home » openjdk-7 » javax » swing » [javadoc | source]