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 }