Package Summary Overview Summary

### class:UIManager [CHANGED]
- All Implemented Interfaces: Serializable
      public class UIManager
      extends Object
      implements Serializable
  `UIManager` manages the current look and feel, the set of available look and feels, `PropertyChangeListeners` that are notified when the look and feel changes, look and feel defaults, and convenience methods for obtaining various default values. ### Specifying the look and feel The look and feel can be specified in two distinct ways: by specifying the fully qualified name of the class for the look and feel, or by creating an instance of `LookAndFeel` and passing it to `setLookAndFeel`. The following example illustrates setting the look and feel to the system look and feel:
         UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  The following example illustrates setting the look and feel based on class name:
         UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
Once the look and feel has been changed it is imperative to invoke `updateUI` on all `JComponents`. The method `SwingUtilities.updateComponentTreeUI(java.awt.Component)` makes it easy to apply `updateUI` to a containment hierarchy. Refer to it for details. The exact behavior of not invoking `updateUI` after changing the look and feel is unspecified. It is very possible to receive unexpected exceptions, painting problems, or worse. ### Default look and feel The class used for the default look and feel is chosen in the following manner: If the system property `swing.defaultlaf` is `non-null`, use its value as the default look and feel class name. If the `Properties` file `swing.properties` exists and contains the key `swing.defaultlaf`, use its value as the default look and feel class name. The location that is checked for `swing.properties` may vary depending upon the implementation of the Java platform. Typically the `swing.properties` file is located in the ``lib`conf` subdirectory of the Java installation directory. Refer to the release notes of the implementation being used for further details. Otherwise use the cross platform look and feel. ### Defaults `UIManager` manages three sets of `UIDefaults`. In order, they are: Developer defaults. With few exceptions Swing does not alter the developer defaults; these are intended to be modified and used by the developer. Look and feel defaults. The look and feel defaults are supplied by the look and feel at the time it is installed as the current look and feel (`setLookAndFeel()` is invoked). The look and feel defaults can be obtained using the `getLookAndFeelDefaults()` method. System defaults. The system defaults are provided by Swing. Invoking any of the various `get` methods results in checking each of the defaults, in order, returning the first `non-null` value. For example, invoking `UIManager.getString("Table.foreground")` results in first checking developer defaults. If the developer defaults contain a value for `"Table.foreground"` it is returned, otherwise the look and feel defaults are checked, followed by the system defaults. It's important to note that `getDefaults` returns a custom instance of `UIDefaults` with this resolution logic built into it. For example, `UIManager.getDefaults().getString("Table.foreground")` is equivalent to `UIManager.getString("Table.foreground")`. Both resolve using the algorithm just described. In many places the documentation uses the word defaults to refer to the custom instance of `UIDefaults` with the resolution logic as previously described. When the look and feel is changed, `UIManager` alters only the look and feel defaults; the developer and system defaults are not altered by the `UIManager` in any way. The set of defaults a particular look and feel supports is defined and documented by that look and feel. In addition, each look and feel, or `ComponentUI` provided by a look and feel, may access the defaults at different times in their life cycle. Some look and feels may aggressively look up defaults, so that changing a default may not have an effect after installing the look and feel. Other look and feels may lazily access defaults so that a change to the defaults may effect an existing look and feel. Finally, other look and feels might not configure themselves from the defaults table in any way. None-the-less it is usually the case that a look and feel expects certain defaults, so that in general a `ComponentUI` provided by one look and feel will not work with another look and feel. Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans™ has been added to the `java.beans` package. Please see `XMLEncoder`. Since: 1.2
- All Implemented Interfaces: Serializable
      public class UIManager
      extends Object
      implements Serializable
  `UIManager` manages the current look and feel, the set of available look and feels, `PropertyChangeListeners` that are notified when the look and feel changes, look and feel defaults, and convenience methods for obtaining various default values. ### Specifying the look and feel The look and feel can be specified in two distinct ways: by specifying the fully qualified name of the class for the look and feel, or by creating an instance of `LookAndFeel` and passing it to `setLookAndFeel`. The following example illustrates setting the look and feel to the system look and feel:
         UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  The following example illustrates setting the look and feel based on class name:
         UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
- Once the look and feel has been changed it is imperative to invoke `updateUI` on all `JComponents`. The method `SwingUtilities.updateComponentTreeUI(java.awt.Component)` makes it easy to apply `updateUI` to a containment hierarchy. Refer to it for details. The exact behavior of not invoking `updateUI` after changing the look and feel is unspecified. It is very possible to receive unexpected exceptions, painting problems, or worse. ### Default look and feel The class used for the default look and feel is chosen in the following manner: If the system property `swing.defaultlaf` is `non-null`, use its value as the default look and feel class name. If the `Properties` file `swing.properties` exists and contains the key `swing.defaultlaf`, use its value as the default look and feel class name. The location that is checked for `swing.properties` may vary depending upon the implementation of the Java platform. Typically the `swing.properties` file is located in the `lib` subdirectory of the Java installation directory. Refer to the release notes of the implementation being used for further details. Otherwise use the cross platform look and feel. ### Defaults `UIManager` manages three sets of `UIDefaults`. In order, they are: Developer defaults. With few exceptions Swing does not alter the developer defaults; these are intended to be modified and used by the developer. Look and feel defaults. The look and feel defaults are supplied by the look and feel at the time it is installed as the current look and feel (`setLookAndFeel()` is invoked). The look and feel defaults can be obtained using the `getLookAndFeelDefaults()` method. System defaults. The system defaults are provided by Swing. Invoking any of the various `get` methods results in checking each of the defaults, in order, returning the first `non-null` value. For example, invoking `UIManager.getString("Table.foreground")` results in first checking developer defaults. If the developer defaults contain a value for `"Table.foreground"` it is returned, otherwise the look and feel defaults are checked, followed by the system defaults. It's important to note that `getDefaults` returns a custom instance of `UIDefaults` with this resolution logic built into it. For example, `UIManager.getDefaults().getString("Table.foreground")` is equivalent to `UIManager.getString("Table.foreground")`. Both resolve using the algorithm just described. In many places the documentation uses the word defaults to refer to the custom instance of `UIDefaults` with the resolution logic as previously described. When the look and feel is changed, `UIManager` alters only the look and feel defaults; the developer and system defaults are not altered by the `UIManager` in any way. The set of defaults a particular look and feel supports is defined and documented by that look and feel. In addition, each look and feel, or `ComponentUI` provided by a look and feel, may access the defaults at different times in their life cycle. Some look and feels may aggressively look up defaults, so that changing a default may not have an effect after installing the look and feel. Other look and feels may lazily access defaults so that a change to the defaults may effect an existing look and feel. Finally, other look and feels might not configure themselves from the defaults table in any way. None-the-less it is usually the case that a look and feel expects certain defaults, so that in general a `ComponentUI` provided by one look and feel will not work with another look and feel. Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans™ has been added to the `java.beans` package. Please see `XMLEncoder`. Since: 1.2 | All Implemented Interfaces: Serializable
      public class UIManager
      extends Object
      implements Serializable
  `UIManager` manages the current look and feel, the set of available look and feels, `PropertyChangeListeners` that are notified when the look and feel changes, look and feel defaults, and convenience methods for obtaining various default values. ### Specifying the look and feel The look and feel can be specified in two distinct ways: by specifying the fully qualified name of the class for the look and feel, or by creating an instance of `LookAndFeel` and passing it to `setLookAndFeel`. The following example illustrates setting the look and feel to the system look and feel:
         UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  The following example illustrates setting the look and feel based on class name:
         UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
Once the look and feel has been changed it is imperative to invoke `updateUI` on all `JComponents`. The method `SwingUtilities.updateComponentTreeUI(java.awt.Component)` makes it easy to apply `updateUI` to a containment hierarchy. Refer to it for details. The exact behavior of not invoking `updateUI` after changing the look and feel is unspecified. It is very possible to receive unexpected exceptions, painting problems, or worse. ### Default look and feel The class used for the default look and feel is chosen in the following manner: If the system property `swing.defaultlaf` is `non-null`, use its value as the default look and feel class name. If the `Properties` file `swing.properties` exists and contains the key `swing.defaultlaf`, use its value as the default look and feel class name. The location that is checked for `swing.properties` may vary depending upon the implementation of the Java platform. Typically the `swing.properties` file is located in the `conf` subdirectory of the Java installation directory. Refer to the release notes of the implementation being used for further details. Otherwise use the cross platform look and feel. ### Defaults `UIManager` manages three sets of `UIDefaults`. In order, they are: Developer defaults. With few exceptions Swing does not alter the developer defaults; these are intended to be modified and used by the developer. Look and feel defaults. The look and feel defaults are supplied by the look and feel at the time it is installed as the current look and feel (`setLookAndFeel()` is invoked). The look and feel defaults can be obtained using the `getLookAndFeelDefaults()` method. System defaults. The system defaults are provided by Swing. Invoking any of the various `get` methods results in checking each of the defaults, in order, returning the first `non-null` value. For example, invoking `UIManager.getString("Table.foreground")` results in first checking developer defaults. If the developer defaults contain a value for `"Table.foreground"` it is returned, otherwise the look and feel defaults are checked, followed by the system defaults. It's important to note that `getDefaults` returns a custom instance of `UIDefaults` with this resolution logic built into it. For example, `UIManager.getDefaults().getString("Table.foreground")` is equivalent to `UIManager.getString("Table.foreground")`. Both resolve using the algorithm just described. In many places the documentation uses the word defaults to refer to the custom instance of `UIDefaults` with the resolution logic as previously described. When the look and feel is changed, `UIManager` alters only the look and feel defaults; the developer and system defaults are not altered by the `UIManager` in any way. The set of defaults a particular look and feel supports is defined and documented by that look and feel. In addition, each look and feel, or `ComponentUI` provided by a look and feel, may access the defaults at different times in their life cycle. Some look and feels may aggressively look up defaults, so that changing a default may not have an effect after installing the look and feel. Other look and feels may lazily access defaults so that a change to the defaults may effect an existing look and feel. Finally, other look and feels might not configure themselves from the defaults table in any way. None-the-less it is usually the case that a look and feel expects certain defaults, so that in general a `ComponentUI` provided by one look and feel will not work with another look and feel. Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans™ has been added to the `java.beans` package. Please see `XMLEncoder`. Since: 1.2

### constructor:UIManager() [NONE]
- #### UIManager
      public UIManager()

### method:getInstalledLookAndFeels() [NONE]
- #### getInstalledLookAndFeels
      public static UIManager.LookAndFeelInfo[] getInstalledLookAndFeels()
  Returns an array of `LookAndFeelInfo`s representing the `LookAndFeel` implementations currently available. The `LookAndFeelInfo` objects can be used by an application to construct a menu of look and feel options for the user, or to determine which look and feel to set at startup time. To avoid the penalty of creating numerous `LookAndFeel` objects, `LookAndFeelInfo` maintains the class name of the `LookAndFeel` class, not the actual `LookAndFeel` instance. The following example illustrates setting the current look and feel from an instance of `LookAndFeelInfo`:
         UIManager.setLookAndFeel(info.getClassName());
Returns: an array of `LookAndFeelInfo` objects See Also: `setLookAndFeel(javax.swing.LookAndFeel)`

### method:setInstalledLookAndFeels(javax.swing.UIManager.LookAndFeelInfo[]) [NONE]
- #### setInstalledLookAndFeels
      public static void setInstalledLookAndFeels(UIManager.LookAndFeelInfo[] infos)
                                           throws SecurityException
Sets the set of available look and feels. While this method does not check to ensure all of the `LookAndFeelInfos` are `non-null`, it is strongly recommended that only `non-null` values are supplied in the `infos` array. Parameters: `infos` - set of `LookAndFeelInfo` objects specifying the available look and feels Throws: `NullPointerException` - if `infos` is `null` `SecurityException` See Also: `getInstalledLookAndFeels()`

### method:installLookAndFeel(javax.swing.UIManager.LookAndFeelInfo) [NONE]
- #### installLookAndFeel
      public static void installLookAndFeel(UIManager.LookAndFeelInfo info)
Adds the specified look and feel to the set of available look and feels. While this method allows a `null` `info`, it is strongly recommended that a `non-null` value be used. Parameters: `info` - a `LookAndFeelInfo` object that names the look and feel and identifies the class that implements it See Also: `setInstalledLookAndFeels(javax.swing.UIManager.LookAndFeelInfo[])`

### method:installLookAndFeel(java.lang.String, java.lang.String) [NONE]
- #### installLookAndFeel
      public static void installLookAndFeel(String name,
                                            String className)
Adds the specified look and feel to the set of available look and feels. While this method does not check the arguments in any way, it is strongly recommended that `non-null` values be supplied. Parameters: `name` - descriptive name of the look and feel `className` - name of the class that implements the look and feel See Also: `setInstalledLookAndFeels(javax.swing.UIManager.LookAndFeelInfo[])`

### method:getLookAndFeel() [NONE]
- #### getLookAndFeel
      public static LookAndFeel getLookAndFeel()
Returns the current look and feel or `null`. Returns: current look and feel, or `null` See Also: `setLookAndFeel(javax.swing.LookAndFeel)`

### method:setLookAndFeel(javax.swing.LookAndFeel) [NONE]
- #### setLookAndFeel
      public static void setLookAndFeel(LookAndFeel newLookAndFeel)
                                 throws UnsupportedLookAndFeelException
Sets the current look and feel to `newLookAndFeel`. If the current look and feel is `non-null` `uninitialize` is invoked on it. If `newLookAndFeel` is `non-null`, `initialize` is invoked on it followed by `getDefaults`. The defaults returned from `newLookAndFeel.getDefaults()` replace those of the defaults from the previous look and feel. If the `newLookAndFeel` is `null`, the look and feel defaults are set to `null`. A value of `null` can be used to set the look and feel to `null`. As the `LookAndFeel` is required for most of Swing to function, setting the `LookAndFeel` to `null` is strongly discouraged. This is a JavaBeans bound property. Parameters: `newLookAndFeel` - `LookAndFeel` to install Throws: `UnsupportedLookAndFeelException` - if `newLookAndFeel` is `non-null` and `newLookAndFeel.isSupportedLookAndFeel()` returns `false` See Also: `getLookAndFeel()`

### method:setLookAndFeel(java.lang.String) [NONE]
- #### setLookAndFeel
      public static void setLookAndFeel(String className)
                                 throws ClassNotFoundException,
                                        InstantiationException,
                                        IllegalAccessException,
                                        UnsupportedLookAndFeelException
Loads the `LookAndFeel` specified by the given class name, using the current thread's context class loader, and passes it to `setLookAndFeel(LookAndFeel)`. Parameters: `className` - a string specifying the name of the class that implements the look and feel Throws: `ClassNotFoundException` - if the `LookAndFeel` class could not be found `InstantiationException` - if a new instance of the class couldn't be created `IllegalAccessException` - if the class or initializer isn't accessible `UnsupportedLookAndFeelException` - if `lnf.isSupportedLookAndFeel()` is false `ClassCastException` - if `className` does not identify a class that extends `LookAndFeel`

### method:getSystemLookAndFeelClassName() [NONE]
- #### getSystemLookAndFeelClassName
      public static String getSystemLookAndFeelClassName()
Returns the name of the `LookAndFeel` class that implements the native system look and feel if there is one, otherwise the name of the default cross platform `LookAndFeel` class. This value can be overriden by setting the `swing.systemlaf` system property. Returns: the `String` of the `LookAndFeel` class See Also: `setLookAndFeel(javax.swing.LookAndFeel)`, `getCrossPlatformLookAndFeelClassName()`

### method:getCrossPlatformLookAndFeelClassName() [NONE]
- #### getCrossPlatformLookAndFeelClassName
      public static String getCrossPlatformLookAndFeelClassName()
Returns the name of the `LookAndFeel` class that implements the default cross platform look and feel -- the Java Look and Feel (JLF). This value can be overriden by setting the `swing.crossplatformlaf` system property. Returns: a string with the JLF implementation-class See Also: `setLookAndFeel(javax.swing.LookAndFeel)`, `getSystemLookAndFeelClassName()`

### method:getDefaults() [NONE]
- #### getDefaults
      public static UIDefaults getDefaults()
Returns the defaults. The returned defaults resolve using the logic specified in the class documentation. Returns: a `UIDefaults` object containing the default values

### method:getFont(java.lang.Object) [NONE]
- #### getFont
      public static Font getFont(Object key)
Returns a font from the defaults. If the value for `key` is not a `Font`, `null` is returned. Parameters: `key` - an `Object` specifying the font Returns: the `Font` object Throws: `NullPointerException` - if `key` is `null`

### method:getFont(java.lang.Object, java.util.Locale) [NONE]
- #### getFont
      public static Font getFont(Object key,
                                 Locale l)
Returns a font from the defaults that is appropriate for the given locale. If the value for `key` is not a `Font`, `null` is returned. Parameters: `key` - an `Object` specifying the font `l` - the `Locale` for which the font is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Font` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getColor(java.lang.Object) [NONE]
- #### getColor
      public static Color getColor(Object key)
Returns a color from the defaults. If the value for `key` is not a `Color`, `null` is returned. Parameters: `key` - an `Object` specifying the color Returns: the `Color` object Throws: `NullPointerException` - if `key` is `null`

### method:getColor(java.lang.Object, java.util.Locale) [NONE]
- #### getColor
      public static Color getColor(Object key,
                                   Locale l)
Returns a color from the defaults that is appropriate for the given locale. If the value for `key` is not a `Color`, `null` is returned. Parameters: `key` - an `Object` specifying the color `l` - the `Locale` for which the color is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Color` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getIcon(java.lang.Object) [NONE]
- #### getIcon
      public static Icon getIcon(Object key)
Returns an `Icon` from the defaults. If the value for `key` is not an `Icon`, `null` is returned. Parameters: `key` - an `Object` specifying the icon Returns: the `Icon` object Throws: `NullPointerException` - if `key` is `null`

### method:getIcon(java.lang.Object, java.util.Locale) [NONE]
- #### getIcon
      public static Icon getIcon(Object key,
                                 Locale l)
Returns an `Icon` from the defaults that is appropriate for the given locale. If the value for `key` is not an `Icon`, `null` is returned. Parameters: `key` - an `Object` specifying the icon `l` - the `Locale` for which the icon is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Icon` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getBorder(java.lang.Object) [NONE]
- #### getBorder
      public static Border getBorder(Object key)
Returns a border from the defaults. If the value for `key` is not a `Border`, `null` is returned. Parameters: `key` - an `Object` specifying the border Returns: the `Border` object Throws: `NullPointerException` - if `key` is `null`

### method:getBorder(java.lang.Object, java.util.Locale) [NONE]
- #### getBorder
      public static Border getBorder(Object key,
                                     Locale l)
Returns a border from the defaults that is appropriate for the given locale. If the value for `key` is not a `Border`, `null` is returned. Parameters: `key` - an `Object` specifying the border `l` - the `Locale` for which the border is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Border` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getString(java.lang.Object) [NONE]
- #### getString
      public static String getString(Object key)
Returns a string from the defaults. If the value for `key` is not a `String`, `null` is returned. Parameters: `key` - an `Object` specifying the string Returns: the `String` Throws: `NullPointerException` - if `key` is `null`

### method:getString(java.lang.Object, java.util.Locale) [NONE]
- #### getString
      public static String getString(Object key,
                                     Locale l)
Returns a string from the defaults that is appropriate for the given locale. If the value for `key` is not a `String`, `null` is returned. Parameters: `key` - an `Object` specifying the string `l` - the `Locale` for which the string is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `String` Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getInt(java.lang.Object) [NONE]
- #### getInt
      public static int getInt(Object key)
Returns an integer from the defaults. If the value for `key` is not an `Integer`, or does not exist, `0` is returned. Parameters: `key` - an `Object` specifying the int Returns: the int Throws: `NullPointerException` - if `key` is `null`

### method:getInt(java.lang.Object, java.util.Locale) [NONE]
- #### getInt
      public static int getInt(Object key,
                               Locale l)
Returns an integer from the defaults that is appropriate for the given locale. If the value for `key` is not an `Integer`, or does not exist, `0` is returned. Parameters: `key` - an `Object` specifying the int `l` - the `Locale` for which the int is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the int Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getBoolean(java.lang.Object) [NONE]
- #### getBoolean
      public static boolean getBoolean(Object key)
Returns a boolean from the defaults which is associated with the key value. If the key is not found or the key doesn't represent a boolean value then `false` is returned. Parameters: `key` - an `Object` specifying the key for the desired boolean value Returns: the boolean value corresponding to the key Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getBoolean(java.lang.Object, java.util.Locale) [NONE]
- #### getBoolean
      public static boolean getBoolean(Object key,
                                       Locale l)
Returns a boolean from the defaults which is associated with the key value and the given `Locale`. If the key is not found or the key doesn't represent a boolean value then `false` will be returned. Parameters: `key` - an `Object` specifying the key for the desired boolean value `l` - the `Locale` for which the boolean is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the boolean value corresponding to the key Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getInsets(java.lang.Object) [NONE]
- #### getInsets
      public static Insets getInsets(Object key)
Returns an `Insets` object from the defaults. If the value for `key` is not an `Insets`, `null` is returned. Parameters: `key` - an `Object` specifying the `Insets` object Returns: the `Insets` object Throws: `NullPointerException` - if `key` is `null`

### method:getInsets(java.lang.Object, java.util.Locale) [NONE]
- #### getInsets
      public static Insets getInsets(Object key,
                                     Locale l)
Returns an `Insets` object from the defaults that is appropriate for the given locale. If the value for `key` is not an `Insets`, `null` is returned. Parameters: `key` - an `Object` specifying the `Insets` object `l` - the `Locale` for which the object is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Insets` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:getDimension(java.lang.Object) [NONE]
- #### getDimension
      public static Dimension getDimension(Object key)
Returns a dimension from the defaults. If the value for `key` is not a `Dimension`, `null` is returned. Parameters: `key` - an `Object` specifying the dimension object Returns: the `Dimension` object Throws: `NullPointerException` - if `key` is `null`

### method:getDimension(java.lang.Object, java.util.Locale) [NONE]
- #### getDimension
      public static Dimension getDimension(Object key,
                                           Locale l)
Returns a dimension from the defaults that is appropriate for the given locale. If the value for `key` is not a `Dimension`, `null` is returned. Parameters: `key` - an `Object` specifying the dimension object `l` - the `Locale` for which the object is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Dimension` object Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:get(java.lang.Object) [NONE]
- #### get
      public static Object get(Object key)
Returns an object from the defaults. Parameters: `key` - an `Object` specifying the desired object Returns: the `Object` Throws: `NullPointerException` - if `key` is `null`

### method:get(java.lang.Object, java.util.Locale) [NONE]
- #### get
      public static Object get(Object key,
                               Locale l)
Returns an object from the defaults that is appropriate for the given locale. Parameters: `key` - an `Object` specifying the desired object `l` - the `Locale` for which the object is desired; refer to `UIDefaults` for details on how a `null` `Locale` is handled Returns: the `Object` Throws: `NullPointerException` - if `key` is `null` Since: 1.4

### method:put(java.lang.Object, java.lang.Object) [NONE]
- #### put
      public static Object put(Object key,
                               Object value)
Stores an object in the developer defaults. This is a cover method for `getDefaults().put(key, value)` . This only effects the developer defaults, not the system or look and feel defaults. Parameters: `key` - an `Object` specifying the retrieval key `value` - the `Object` to store; refer to `UIDefaults` for details on how `null` is handled Returns: the `Object` returned by `UIDefaults.put(java.lang.Object, java.lang.Object)` Throws: `NullPointerException` - if `key` is `null` See Also: `UIDefaults.put(java.lang.Object, java.lang.Object)`

### method:getUI(javax.swing.JComponent) [NONE]
- #### getUI
      public static ComponentUI getUI(JComponent target)
Returns the appropriate `ComponentUI` implementation for `target`. Typically, this is a cover for `getDefaults().getUI(target)`. However, if an auxiliary look and feel has been installed, this first invokes `getUI(target)` on the multiplexing look and feel's defaults, and returns that value if it is `non-null`. Parameters: `target` - the `JComponent` to return the `ComponentUI` for Returns: the `ComponentUI` object for `target` Throws: `NullPointerException` - if `target` is `null` See Also: `UIDefaults.getUI(javax.swing.JComponent)`

### method:getLookAndFeelDefaults() [NONE]
- #### getLookAndFeelDefaults
      public static UIDefaults getLookAndFeelDefaults()
Returns the `UIDefaults` from the current look and feel, that were obtained at the time the look and feel was installed. In general, developers should use the `UIDefaults` returned from `getDefaults()`. As the current look and feel may expect certain values to exist, altering the `UIDefaults` returned from this method could have unexpected results. Returns: `UIDefaults` from the current look and feel See Also: `getDefaults()`, `setLookAndFeel(LookAndFeel)`, `LookAndFeel.getDefaults()`

### method:addAuxiliaryLookAndFeel(javax.swing.LookAndFeel) [NONE]
- #### addAuxiliaryLookAndFeel
      public static void addAuxiliaryLookAndFeel(LookAndFeel laf)
Adds a `LookAndFeel` to the list of auxiliary look and feels. The auxiliary look and feels tell the multiplexing look and feel what other `LookAndFeel` classes for a component instance are to be used in addition to the default `LookAndFeel` class when creating a multiplexing UI. The change will only take effect when a new UI class is created or when the default look and feel is changed on a component instance. Note these are not the same as the installed look and feels. Parameters: `laf` - the `LookAndFeel` object See Also: `removeAuxiliaryLookAndFeel(javax.swing.LookAndFeel)`, `setLookAndFeel(javax.swing.LookAndFeel)`, `getAuxiliaryLookAndFeels()`, `getInstalledLookAndFeels()`

### method:removeAuxiliaryLookAndFeel(javax.swing.LookAndFeel) [NONE]
- #### removeAuxiliaryLookAndFeel
      public static boolean removeAuxiliaryLookAndFeel(LookAndFeel laf)
Removes a `LookAndFeel` from the list of auxiliary look and feels. The auxiliary look and feels tell the multiplexing look and feel what other `LookAndFeel` classes for a component instance are to be used in addition to the default `LookAndFeel` class when creating a multiplexing UI. The change will only take effect when a new UI class is created or when the default look and feel is changed on a component instance. Note these are not the same as the installed look and feels. Parameters: `laf` - the `LookAndFeel` to be removed Returns: true if the `LookAndFeel` was removed from the list See Also: `removeAuxiliaryLookAndFeel(javax.swing.LookAndFeel)`, `getAuxiliaryLookAndFeels()`, `setLookAndFeel(javax.swing.LookAndFeel)`, `getInstalledLookAndFeels()`

### method:getAuxiliaryLookAndFeels() [NONE]
- #### getAuxiliaryLookAndFeels
      public static LookAndFeel[] getAuxiliaryLookAndFeels()
Returns the list of auxiliary look and feels (can be `null`). The auxiliary look and feels tell the multiplexing look and feel what other `LookAndFeel` classes for a component instance are to be used in addition to the default LookAndFeel class when creating a multiplexing UI. Note these are not the same as the installed look and feels. Returns: list of auxiliary `LookAndFeel`s or `null` See Also: `addAuxiliaryLookAndFeel(javax.swing.LookAndFeel)`, `removeAuxiliaryLookAndFeel(javax.swing.LookAndFeel)`, `setLookAndFeel(javax.swing.LookAndFeel)`, `getInstalledLookAndFeels()`

### method:addPropertyChangeListener(java.beans.PropertyChangeListener) [NONE]
- #### addPropertyChangeListener
      public static void addPropertyChangeListener(PropertyChangeListener listener)
Adds a `PropertyChangeListener` to the listener list. The listener is registered for all properties. Parameters: `listener` - the `PropertyChangeListener` to be added See Also: `PropertyChangeSupport`

### method:removePropertyChangeListener(java.beans.PropertyChangeListener) [NONE]
- #### removePropertyChangeListener
      public static void removePropertyChangeListener(PropertyChangeListener listener)
Removes a `PropertyChangeListener` from the listener list. This removes a `PropertyChangeListener` that was registered for all properties. Parameters: `listener` - the `PropertyChangeListener` to be removed See Also: `PropertyChangeSupport`

### method:getPropertyChangeListeners() [NONE]
- #### getPropertyChangeListeners
      public static PropertyChangeListener[] getPropertyChangeListeners()
Returns an array of all the `PropertyChangeListener`s added to this UIManager with addPropertyChangeListener(). Returns: all of the `PropertyChangeListener`s added or an empty array if no listeners have been added Since: 1.4