public static  void addAuxiliaryLookAndFeel(LookAndFeel laf) 
{
        maybeInitialize();
        if (!laf.isSupportedLookAndFeel()) {
            // Ideally we would throw an exception here, but it's too late
            // for that.
            return;
        }
        Vector< LookAndFeel > v = getLAFState().auxLookAndFeels;
        if (v == null) {
            v = new Vector< LookAndFeel >();
        }
        if (!v.contains(laf)) {
            v.addElement(laf);
            laf.initialize();
            getLAFState().auxLookAndFeels = v;
            if (getLAFState().multiLookAndFeel == null) {
                getLAFState().multiLookAndFeel = getMultiLookAndFeel();
            }
        }
}

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.

 public static  void addPropertyChangeListener(PropertyChangeListener listener) 
{
        synchronized (classLock) {
            getLAFState().getPropertyChangeSupport(true).
                             addPropertyChangeListener(listener);
        }
}

Adds a PropertyChangeListener to the listener list. The listener is registered for all properties.

 public static Object get(Object key) 
{
        return getDefaults().get(key);
}

Returns an object from the defaults.

 public static Object get(Object key,
    Locale l) 
{
        return getDefaults().get(key,l);
}

Returns an object from the defaults that is appropriate for the given locale.

 public static LookAndFeel[] getAuxiliaryLookAndFeels() 
{
        maybeInitialize();
        Vector< LookAndFeel > v = getLAFState().auxLookAndFeels;
        if ((v == null) || (v.size() == 0)) {
            return null;
        }
        else {
            LookAndFeel[] rv = new LookAndFeel[v.size()];
            for (int i = 0; i <  rv.length; i++) {
                rv[i] = v.elementAt(i);
            }
            return rv;
        }
}

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.

 public static boolean getBoolean(Object key) 
{
        return getDefaults().getBoolean(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 {@code false} is returned.

 public static boolean getBoolean(Object key,
    Locale l) 
{
        return getDefaults().getBoolean(key,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 {@code false} will be returned.

 public static Border getBorder(Object key) 
{
        return getDefaults().getBorder(key);
}

Returns a border from the defaults. If the value for {@code key} is not a {@code Border}, {@code null} is returned.

 public static Border getBorder(Object key,
    Locale l) 
{
        return getDefaults().getBorder(key,l);
}

Returns a border from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code Border}, {@code null} is returned.

 public static Color getColor(Object key) 
{
        return getDefaults().getColor(key);
}

Returns a color from the defaults. If the value for {@code key} is not a {@code Color}, {@code null} is returned.

 public static Color getColor(Object key,
    Locale l) 
{
        return getDefaults().getColor(key,l);
}

Returns a color from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code Color}, {@code null} is returned.

 public static String getCrossPlatformLookAndFeelClassName() 
{
        String laf = AccessController.doPrivileged(
                             new GetPropertyAction("swing.crossplatformlaf"));
        if (laf != null) {
            return laf;
        }
        return "javax.swing.plaf.metal.MetalLookAndFeel";
}

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.

 public static UIDefaults getDefaults() 
{
        maybeInitialize();
        return getLAFState().multiUIDefaults;
}

Returns the defaults. The returned defaults resolve using the logic specified in the class documentation.

 public static Dimension getDimension(Object key) 
{
        return getDefaults().getDimension(key);
}

Returns a dimension from the defaults. If the value for {@code key} is not a {@code Dimension}, {@code null} is returned.

 public static Dimension getDimension(Object key,
    Locale l) 
{
        return getDefaults().getDimension(key,l);
}

Returns a dimension from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code Dimension}, {@code null} is returned.

 public static Font getFont(Object key) 
{
        return getDefaults().getFont(key);
}

Returns a font from the defaults. If the value for {@code key} is not a {@code Font}, {@code null} is returned.

 public static Font getFont(Object key,
    Locale l) 
{
        return getDefaults().getFont(key,l);
}

Returns a font from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code Font}, {@code null} is returned.

 public static Icon getIcon(Object key) 
{
        return getDefaults().getIcon(key);
}

Returns an Icon from the defaults. If the value for {@code key} is not an {@code Icon}, {@code null} is returned.

 public static Icon getIcon(Object key,
    Locale l) 
{
        return getDefaults().getIcon(key,l);
}

Returns an Icon from the defaults that is appropriate for the given locale. If the value for {@code key} is not an {@code Icon}, {@code null} is returned.

 public static Insets getInsets(Object key) 
{
        return getDefaults().getInsets(key);
}

Returns an Insets object from the defaults. If the value for {@code key} is not an {@code Insets}, {@code null} is returned.

 public static Insets getInsets(Object key,
    Locale l) 
{
        return getDefaults().getInsets(key,l);
}

Returns an Insets object from the defaults that is appropriate for the given locale. If the value for {@code key} is not an {@code Insets}, {@code null} is returned.

 public static LookAndFeelInfo[] getInstalledLookAndFeels() 
{
        maybeInitialize();
        LookAndFeelInfo[] ilafs = getLAFState().installedLAFs;
        if (ilafs == null) {
            ilafs = installedLAFs;
        }
        LookAndFeelInfo[] rv = new LookAndFeelInfo[ilafs.length];
        System.arraycopy(ilafs, 0, rv, 0, ilafs.length);
        return rv;
}

Returns an array of {@code LookAndFeelInfo}s representing the {@code 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 {@code LookAndFeel} objects, {@code LookAndFeelInfo} maintains the class name of the {@code LookAndFeel} class, not the actual {@code LookAndFeel} instance.

The following example illustrates setting the current look and feel from an instance of {@code LookAndFeelInfo}:

  UIManager.setLookAndFeel(info.getClassName());

 public static int getInt(Object key) 
{
        return getDefaults().getInt(key);
}

Returns an integer from the defaults. If the value for {@code key} is not an {@code Integer}, or does not exist, {@code 0} is returned.

 public static int getInt(Object key,
    Locale l) 
{
        return getDefaults().getInt(key,l);
}

Returns an integer from the defaults that is appropriate for the given locale. If the value for {@code key} is not an {@code Integer}, or does not exist, {@code 0} is returned.

 public static LookAndFeel getLookAndFeel() 
{
        maybeInitialize();
        return getLAFState().lookAndFeel;
}

Returns the current look and feel or null.

 public static UIDefaults getLookAndFeelDefaults() 
{
        maybeInitialize();
        return getLAFState().getLookAndFeelDefaults();
}

Returns the {@code 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 {@code UIDefaults} returned from {@code getDefaults()}. As the current look and feel may expect certain values to exist, altering the {@code UIDefaults} returned from this method could have unexpected results.

 public static PropertyChangeListener[] getPropertyChangeListeners() 
{
        synchronized(classLock) {
            return getLAFState().getPropertyChangeSupport(true).
                      getPropertyChangeListeners();
        }
}

Returns an array of all the PropertyChangeListeners added to this UIManager with addPropertyChangeListener().

 public static String getString(Object key) 
{
        return getDefaults().getString(key);
}

Returns a string from the defaults. If the value for {@code key} is not a {@code String}, {@code null} is returned.

 public static String getString(Object key,
    Locale l) 
{
        return getDefaults().getString(key,l);
}

Returns a string from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code String}, {@code null} is returned.

 static String getString(Object key,
    Component c) 
{
        Locale l = (c == null) ? Locale.getDefault() : c.getLocale();
        return getString(key, l);
}

Returns a string from the defaults that is appropriate for the given locale. If the value for {@code key} is not a {@code String}, {@code null} is returned.

 public static String getSystemLookAndFeelClassName() 
{
        String systemLAF = AccessController.doPrivileged(
                             new GetPropertyAction("swing.systemlaf"));
        if (systemLAF != null) {
            return systemLAF;
        }
        OSInfo.OSType osType = AccessController.doPrivileged(OSInfo.getOSTypeAction());
        if (osType == OSInfo.OSType.WINDOWS) {
            return "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
        } else {
            String desktop = AccessController.doPrivileged(new GetPropertyAction("sun.desktop"));
            Toolkit toolkit = Toolkit.getDefaultToolkit();
            if ("gnome".equals(desktop) &&
                    toolkit instanceof SunToolkit &&
                    ((SunToolkit) toolkit).isNativeGTKAvailable()) {
                // May be set on Linux and Solaris boxs.
                return "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
            }
            if (osType == OSInfo.OSType.SOLARIS) {
                return "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
            }
        }
        return getCrossPlatformLookAndFeelClassName();
}

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.

 public static ComponentUI getUI(JComponent target) 
{
        maybeInitialize();
        ComponentUI ui = null;
        LookAndFeel multiLAF = getLAFState().multiLookAndFeel;
        if (multiLAF != null) {
            // This can return null if the multiplexing look and feel
            // doesn't support a particular UI.
            ui = multiLAF.getDefaults().getUI(target);
        }
        if (ui == null) {
            ui = getDefaults().getUI(target);
        }
        return ui;
}

Returns the appropriate {@code ComponentUI} implementation for {@code target}. Typically, this is a cover for {@code getDefaults().getUI(target)}. However, if an auxiliary look and feel has been installed, this first invokes {@code getUI(target)} on the multiplexing look and feel's defaults, and returns that value if it is {@code non-null}.

 public static  void installLookAndFeel(LookAndFeelInfo info) 
{
        LookAndFeelInfo[] infos = getInstalledLookAndFeels();
        LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length + 1];
        System.arraycopy(infos, 0, newInfos, 0, infos.length);
        newInfos[infos.length] = info;
        setInstalledLookAndFeels(newInfos);
}

Adds the specified look and feel to the set of available look and feels. While this method allows a {@code null} {@code info}, it is strongly recommended that a {@code non-null} value be used.

 public static  void installLookAndFeel(String name,
    String className) 
{
        installLookAndFeel(new LookAndFeelInfo(name, 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 {@code non-null} values be supplied.

 public static Object put(Object key,
    Object value) 
{
        return getDefaults().put(key, value);
}

Stores an object in the developer defaults. This is a cover method for {@code getDefaults().put(key, value)}. This only effects the developer defaults, not the system or look and feel defaults.

 public static boolean removeAuxiliaryLookAndFeel(LookAndFeel laf) 
{
        maybeInitialize();
        boolean result;
        Vector< LookAndFeel > v = getLAFState().auxLookAndFeels;
        if ((v == null) || (v.size() == 0)) {
            return false;
        }
        result = v.removeElement(laf);
        if (result) {
            if (v.size() == 0) {
                getLAFState().auxLookAndFeels = null;
                getLAFState().multiLookAndFeel = null;
            } else {
                getLAFState().auxLookAndFeels = v;
            }
        }
        laf.uninitialize();
        return result;
}

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.

 public static  void removePropertyChangeListener(PropertyChangeListener listener) 
{
        synchronized (classLock) {
            getLAFState().getPropertyChangeSupport(true).
                          removePropertyChangeListener(listener);
        }
}

Removes a PropertyChangeListener from the listener list. This removes a PropertyChangeListener that was registered for all properties.

 public static  void setInstalledLookAndFeels(LookAndFeelInfo[] infos) throws SecurityException 
{
        maybeInitialize();
        LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length];
        System.arraycopy(infos, 0, newInfos, 0, infos.length);
        getLAFState().installedLAFs = newInfos;
}

Sets the set of available look and feels. While this method does not check to ensure all of the {@code LookAndFeelInfos} are {@code non-null}, it is strongly recommended that only {@code non-null} values are supplied in the {@code infos} array.

 public static  void setLookAndFeel(LookAndFeel newLookAndFeel) throws UnsupportedLookAndFeelException 
{
        if ((newLookAndFeel != null) && !newLookAndFeel.isSupportedLookAndFeel()) {
            String s = newLookAndFeel.toString() + " not supported on this platform";
            throw new UnsupportedLookAndFeelException(s);
        }
        LAFState lafState = getLAFState();
        LookAndFeel oldLookAndFeel = lafState.lookAndFeel;
        if (oldLookAndFeel != null) {
            oldLookAndFeel.uninitialize();
        }
        lafState.lookAndFeel = newLookAndFeel;
        if (newLookAndFeel != null) {
            sun.swing.DefaultLookup.setDefaultLookup(null);
            newLookAndFeel.initialize();
            lafState.setLookAndFeelDefaults(newLookAndFeel.getDefaults());
        }
        else {
            lafState.setLookAndFeelDefaults(null);
        }
        SwingPropertyChangeSupport changeSupport = lafState.
                                         getPropertyChangeSupport(false);
        if (changeSupport != null) {
            changeSupport.firePropertyChange("lookAndFeel", oldLookAndFeel,
                                             newLookAndFeel);
        }
}

Sets the current look and feel to {@code newLookAndFeel}. If the current look and feel is {@code non-null} {@code uninitialize} is invoked on it. If {@code newLookAndFeel} is {@code non-null}, {@code initialize} is invoked on it followed by {@code getDefaults}. The defaults returned from {@code newLookAndFeel.getDefaults()} replace those of the defaults from the previous look and feel. If the {@code newLookAndFeel} is {@code null}, the look and feel defaults are set to {@code null}.

A value of {@code null} can be used to set the look and feel to {@code null}. As the {@code LookAndFeel} is required for most of Swing to function, setting the {@code LookAndFeel} to {@code null} is strongly discouraged.

This is a JavaBeans bound property.

 public static  void setLookAndFeel(String className) throws ClassNotFoundException, InstantiationException, IllegalAccessException, UnsupportedLookAndFeelException 
{
        if ("javax.swing.plaf.metal.MetalLookAndFeel".equals(className)) {
            // Avoid reflection for the common case of metal.
            setLookAndFeel(new javax.swing.plaf.metal.MetalLookAndFeel());
        }
        else {
            Class lnfClass = SwingUtilities.loadSystemClass(className);
            setLookAndFeel((LookAndFeel)(lnfClass.newInstance()));
        }
}

Loads the {@code LookAndFeel} specified by the given class name, using the current thread's context class loader, and passes it to {@code setLookAndFeel(LookAndFeel)}.