libjava/javax/swing/UIDefaults.java

   1 /* UIDefaults.java -- database for all settings and interface bindings.
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package javax.swing;
  39
  40 import java.awt.Color;
  41 import java.awt.Dimension;
  42 import java.awt.Font;
  43 import java.awt.Insets;
  44 import java.beans.PropertyChangeEvent;
  45 import java.beans.PropertyChangeListener;
  46 import java.lang.reflect.Method;
  47 import java.lang.reflect.Constructor;
  48 import java.util.Hashtable;
  49 import java.util.Iterator;
  50 import java.util.List;
  51 import java.util.ListIterator;
  52 import java.util.LinkedList;
  53 import java.util.Locale;
  54 import java.util.Set;
  55 import java.util.HashSet;
  56 import java.util.MissingResourceException;
  57 import java.util.ResourceBundle;
  58 import javax.swing.border.Border;
  59 import javax.swing.plaf.ComponentUI;
  60
  61 /**
  62  * UIDefaults is a database where all settings and interface bindings are
  63  * stored into. An PLAF implementation fills one of these (see for example
  64  * plaf/basic/BasicDefaults.java) with "JButton" -> new BasicButtonUI().
  65  *
  66  * @author Ronald Veldema (rveldema@cs.vu.nl)
  67  */
  68 public class UIDefaults extends Hashtable
  69 {
  70
  71   LinkedList bundles;
  72   Set listeners;
  73   Locale defaultLocale;
  74
  75   interface ActiveValue
  76   {
  77     Object createValue(UIDefaults table);
  78   } // interface ActiveValue
  79
  80   public static class LazyInputMap implements LazyValue
  81   {
  82     Object[] bind;
  83     public LazyInputMap(Object[] bindings)
  84     {
  85       bind = bindings;
  86     }
  87     public Object createValue(UIDefaults table)
  88     {
  89       InputMap im = new InputMap ();
  90       for (int i = 0; 2*i+1 < bind.length; ++i)
  91         {
  92           im.put (KeyStroke.getKeyStroke ((String) bind[2*i]),
  93                   bind[2*i+1]);
  94         }
  95       return im;
  96     }
  97   } // class LazyInputMap
  98
  99   interface LazyValue
 100   {
 101     Object createValue(UIDefaults table);
 102   } // interface LazyValue
 103
 104   public static class ProxyLazyValue implements LazyValue
 105   {
 106     LazyValue inner;
 107     public ProxyLazyValue(String s)
 108     {
 109       final String className = s;
 110       inner = new LazyValue ()
 111         {
 112           public Object createValue (UIDefaults table)
 113           {
 114             try
 115               {
 116                 return Class
 117                   .forName (className)
 118                   .getConstructor (new Class[] {})
 119                   .newInstance (new Object[] {});
 120               }
 121             catch (Exception e)
 122               {
 123                 return null;
 124               }
 125           }
 126         };
 127     }
 128
 129     public ProxyLazyValue(String c, String m)
 130     {
 131       final String className = c;
 132       final String methodName = m;
 133       inner = new LazyValue ()
 134         {
 135           public Object createValue (UIDefaults table)
 136           {
 137             try
 138               {
 139                 return Class
 140                   .forName (className)
 141                   .getMethod (methodName, new Class[] {})
 142                   .invoke (null, new Object[] {});
 143               }
 144             catch (Exception e)
 145               {
 146                 return null;
 147               }
 148           }
 149         };
 150     }
 151
 152     public ProxyLazyValue (String c, Object[] os)
 153     {
 154       final String className = c;
 155       final Object[] objs = os;
 156       final Class[] clss = new Class[objs.length];
 157       for (int i = 0; i < objs.length; ++i)
 158         {
 159           clss[i] = objs[i].getClass ();
 160         }
 161       inner = new LazyValue ()
 162         {
 163           public Object createValue (UIDefaults table)
 164           {
 165             try
 166               {
 167                 return Class
 168                   .forName (className)
 169                   .getConstructor (clss)
 170                   .newInstance (objs);
 171     }
 172             catch (Exception e)
 173     {
 174                 return null;
 175               }
 176           }
 177         };
 178     }
 179
 180     public ProxyLazyValue (String c, String m, Object[] os)
 181     {
 182       final String className = c;
 183       final String methodName = m;
 184       final Object[] objs = os;
 185       final Class[] clss = new Class[objs.length];
 186       for (int i = 0; i < objs.length; ++i)
 187     {
 188           clss[i] = objs[i].getClass ();
 189     }
 190       inner = new LazyValue ()
 191         {
 192     public Object createValue(UIDefaults table)
 193     {
 194             try
 195               {
 196                 return Class
 197                   .forName (className)
 198                   .getMethod (methodName, clss)
 199                   .invoke (null, objs);
 200               }
 201             catch (Exception e)
 202               {
 203                 return null;
 204               }
 205           }
 206         };
 207     }
 208
 209     public Object createValue (UIDefaults table)
 210     {
 211       return inner.createValue (table);
 212     }
 213   } // class ProxyLazyValue
 214
 215   private static final long serialVersionUID = 7341222528856548117L;
 216
 217   public UIDefaults()
 218   {
 219     bundles = new LinkedList ();
 220     listeners = new HashSet ();
 221     defaultLocale = Locale.getDefault ();
 222   }
 223
 224   public UIDefaults(Object[] entries)
 225   {
 226     bundles = new LinkedList ();
 227     listeners = new HashSet ();
 228     defaultLocale = Locale.getDefault ();
 229
 230     for (int i = 0; (2*i+1) < entries.length; ++i)
 231       {
 232         put (entries[2*i], entries[2*i+1]);
 233       }
 234   }
 235
 236   public Object get(Object key)
 237   {
 238     return this.get (key, getDefaultLocale ());
 239   }
 240
 241   public Object get (Object key, Locale loc)
 242   {
 243     Object obj = null;
 244
 245     if (super.containsKey (key))
 246       {
 247         obj = super.get (key);
 248       }
 249     else if (key instanceof String)
 250       {
 251         String keyString = (String) key;
 252         ListIterator i = bundles.listIterator (0);
 253         while (i.hasNext ())
 254   {
 255             String bundle_name = (String) i.next ();
 256             ResourceBundle res =
 257               ResourceBundle.getBundle (bundle_name, loc);
 258             if (res != null)
 259               {
 260                 try
 261                   {
 262                     obj = res.getObject (keyString);
 263                     break;
 264                   }
 265                 catch (MissingResourceException me)
 266                   {
 267                     // continue, this bundle has no such key
 268                   }
 269               }
 270           }
 271       }
 272
 273     // now we've found the object, resolve it.
 274     // nb: LazyValues aren't supported in resource bundles, so it's correct
 275     // to insert their results in the locale-less hashtable.
 276
 277     if (obj == null)
 278       return null;
 279
 280     if (obj instanceof LazyValue)
 281       {
 282         Object resolved = ((LazyValue)obj).createValue (this);
 283         super.remove (key);
 284         super.put (key, resolved);
 285         return resolved;
 286       }
 287     else if (obj instanceof ActiveValue)
 288       {
 289         return ((ActiveValue)obj).createValue (this);
 290       }
 291
 292     return obj;
 293   }
 294
 295   public Object put(Object key, Object value)
 296   {
 297     Object old = super.put (key, value);
 298     if (key instanceof String && old != value)
 299       firePropertyChange ((String) key, old, value);
 300     return old;
 301   }
 302
 303   public void putDefaults(Object[] entries)
 304   {
 305     for (int i = 0; (2*i+1) < entries.length; ++i)
 306   {
 307         super.put (entries[2*i], entries[2*i+1]);
 308       }
 309     firePropertyChange ("UIDefaults", null, null);
 310   }
 311
 312   public Font getFont(Object key)
 313   {
 314     Object o = get(key);
 315     return o instanceof Font ? (Font) o : null;
 316   }
 317
 318   public Font getFont(Object key, Locale l)
 319   {
 320     Object o = get(key, l);
 321     return o instanceof Font ? (Font) o : null;
 322   }
 323
 324   public Color getColor(Object key)
 325   {
 326     Object o = get(key);
 327     return o instanceof Color ? (Color) o : null;
 328   }
 329
 330   public Color getColor(Object key, Locale l)
 331   {
 332     Object o = get(key, l);
 333     return o instanceof Color ? (Color) o : null;
 334   }
 335
 336   public Icon getIcon(Object key)
 337   {
 338     Object o = get(key);
 339     return o instanceof Icon ? (Icon) o : null;
 340   }
 341
 342   public Icon getIcon(Object key, Locale l)
 343   {
 344     Object o = get(key, l);
 345     return o instanceof Icon ? (Icon) o : null;
 346   }
 347
 348   public Border getBorder(Object key)
 349   {
 350     Object o = get(key);
 351     return o instanceof Border ? (Border) o : null;
 352   }
 353
 354   public Border getBorder(Object key, Locale l)
 355   {
 356     Object o = get(key, l);
 357     return o instanceof Border ? (Border) o : null;
 358   }
 359
 360   public String getString(Object key)
 361   {
 362     Object o = get(key);
 363     return o instanceof String ? (String) o : null;
 364   }
 365
 366   public String getString(Object key, Locale l)
 367   {
 368     Object o = get(key, l);
 369     return o instanceof String ? (String) o : null;
 370   }
 371
 372   int getInt(Object key)
 373   {
 374     Object o = get(key);
 375     return o instanceof Integer ? ((Integer) o).intValue() : 0;
 376   }
 377
 378   int getInt(Object key, Locale l)
 379   {
 380     Object o = get(key, l);
 381     return o instanceof Integer ? ((Integer) o).intValue() : 0;
 382   }
 383
 384   public boolean getBoolean(Object key)
 385   {
 386     return Boolean.TRUE.equals(get(key));
 387   }
 388
 389   public boolean getBoolean(Object key, Locale l)
 390   {
 391     return Boolean.TRUE.equals(get(key, l));
 392   }
 393
 394   public Insets getInsets(Object key)
 395   {
 396     Object o = get(key);
 397     return o instanceof Insets ? (Insets) o : null;
 398   }
 399
 400   public Insets getInsets(Object key, Locale l)
 401   {
 402     Object o = get(key, l);
 403     return o instanceof Insets ? (Insets) o : null;
 404   }
 405
 406   public Dimension getDimension(Object key)
 407   {
 408     Object o = get(key);
 409     return o instanceof Dimension ? (Dimension) o : null;
 410   }
 411
 412   public Dimension getDimension(Object key, Locale l)
 413   {
 414     Object o = get(key, l);
 415     return o instanceof Dimension ? (Dimension) o : null;
 416   }
 417
 418   public Class getUIClass(String id, ClassLoader loader)
 419   {
 420     String className = (String) get (id);
 421     if (className == null)
 422       return null;
 423     try
 424       {
 425         if (loader != null)
 426           return loader.loadClass (className);
 427         return Class.forName (className);
 428       }
 429     catch (Exception e)
 430       {
 431         return null;
 432       }
 433   }
 434
 435   public Class getUIClass(String id)
 436   {
 437     return getUIClass (id, null);
 438   }
 439
 440   protected void getUIError(String msg)
 441   {
 442     System.err.println ("UIDefaults.getUIError: " + msg);
 443   }
 444
 445   public ComponentUI getUI(JComponent target)
 446   {
 447     String classId = target.getUIClassID ();
 448     Class cls = getUIClass (classId);
 449     if (cls == null)
 450       {
 451         getUIError ("failed to locate UI class:" + classId);
 452         return null;
 453       }
 454
 455     Method factory;
 456
 457     try
 458       {
 459         factory = cls.getMethod ("createUI", new Class[] { JComponent.class } );
 460       }
 461     catch (NoSuchMethodException nme)
 462       {
 463         getUIError ("failed to locate createUI method on " + cls.toString ());
 464         return null;
 465   }
 466
 467     try
 468   {
 469         return (ComponentUI) factory.invoke (null, new Object[] { target });
 470   }
 471     catch (java.lang.reflect.InvocationTargetException ite)
 472         {
 473         getUIError ("InvocationTargetException ("+ ite.getTargetException()
 474                     +") calling createUI(...) on " + cls.toString ());
 475         return null;
 476
 477         }
 478     catch (Exception e)
 479   {
 480         getUIError ("exception calling createUI(...) on " + cls.toString ());
 481         return null;
 482       }
 483   }
 484
 485   void addPropertyChangeListener(PropertyChangeListener listener)
 486   {
 487     listeners.add (listener);
 488   }
 489
 490   void removePropertyChangeListener(PropertyChangeListener listener)
 491   {
 492     listeners.remove (listener);
 493   }
 494
 495   public PropertyChangeListener[] getPropertyChangeListeners()
 496   {
 497     return (PropertyChangeListener[]) listeners.toArray ();
 498   }
 499
 500   protected void firePropertyChange(String property, Object o, Object n)
 501   {
 502     Iterator i = listeners.iterator ();
 503     PropertyChangeEvent pce = new PropertyChangeEvent (this, property, o, n);
 504     while (i.hasNext ())
 505       {
 506         PropertyChangeListener pcl = (PropertyChangeListener) i.next ();
 507         pcl.propertyChange (pce);
 508       }
 509   }
 510
 511   void addResourceBundle(String name)
 512   {
 513     bundles.addFirst (name);
 514   }
 515
 516   void removeResourceBundle(String name)
 517   {
 518     bundles.remove (name);
 519   }
 520
 521   void setDefaultLocale(Locale loc)
 522   {
 523     defaultLocale = loc;
 524   }
 525
 526   public Locale getDefaultLocale()
 527   {
 528     return defaultLocale;
 529   }
 530 } // class UIDefaults