Convenient base class for defining Painter instances for rendering a
region or component in Nimbus.

A class encapsulating state useful when painting. Generally, instances of this
class are created once, and reused for each paint request without modification.
This class contains values useful when hinting the cache engine, and when decoding
control points and bezier curve anchors.

The NimbusLookAndFeel class.

JButton.States = Enabled, Disabled, Toolbar
JButton[Enabled].backgroundPainter = somePainter
JButton[Disabled].background = BLUE
JButton[Toolbar].backgroundPainter = someOtherPaint

A SynthStyle implementation used by Nimbus. Each Region that has been
registered with the NimbusLookAndFeel will have an associated NimbusStyle.
Third party components that are registered with the NimbusLookAndFeel will
therefore be handed a NimbusStyle from the look and feel from the
#getStyle(JComponent, Region) method.

This class properly reads and retrieves values placed in the UIDefaults
according to the standard Nimbus naming conventions. It will create and
retrieve painters, fonts, colors, and other data stored there.

NimbusStyle also supports the ability to override settings on a per
component basis. NimbusStyle checks the component's client property map for
"Nimbus.Overrides". If the value associated with this key is an instance of
UIDefaults, then the values in that defaults table will override the standard
Nimbus defaults in UIManager, but for that component instance only.

Optionally, you may specify the client property
"Nimbus.Overrides.InheritDefaults". If true, this client property indicates
that the defaults located in UIManager should first be read, and then
replaced with defaults located in the component client properties. If false,
then only the defaults located in the component client property map will
be used. If not specified, it is assumed to be true.

You must specify "Nimbus.Overrides" for "Nimbus.Overrides.InheritDefaults"
to have any effect. "Nimbus.Overrides" indicates whether there are any
overrides, while "Nimbus.Overrides.InheritDefaults" indicates whether those
overrides should first be initialized with the defaults from UIManager.

The NimbusStyle is reloaded whenever a property change event is fired
for a component for "Nimbus.Overrides" or "Nimbus.Overrides.InheritDefaults".
So for example, setting a new UIDefaults on a component would cause the
style to be reloaded.

The values are only read out of UIManager once, and then cached. If
you need to read the values again (for example, if the UI is being reloaded),
then discard this NimbusStyle and read a new one from NimbusLookAndFeel
using NimbusLookAndFeel.getStyle.

The primary API of interest in this class for 3rd party component authors
are the three methods which retrieve painters: #getBackgroundPainter,
#getForegroundPainter, and #getBorderPainter.

NimbusStyle allows you to specify custom states, or modify the order of
states. Synth (and thus Nimbus) has the concept of a "state". For example,
a JButton might be in the "MOUSE_OVER" state, or the "ENABLED" state, or the
"DISABLED" state. These are all "standard" states which are defined in synth,
and which apply to all synth Regions.

Sometimes, however, you need to have a custom state. For example, you
want JButton to render differently if it's parent is a JToolbar. In Nimbus,
you specify these custom states by including a special key in UIDefaults.
The following UIDefaults entries define three states for this button:



    JButton.States = Enabled, Disabled, Toolbar
    JButton[Enabled].backgroundPainter = somePainter
    JButton[Disabled].background = BLUE
    JButton[Toolbar].backgroundPainter = someOtherPaint

As you can see, the JButton.States entry lists the states
that the JButton style will support. You then specify the settings for
each state. If you do not specify the JButton.States entry,
then the standard Synth states will be assumed. If you specify the entry
but the list of states is empty or null, then the standard synth states
will be assumed.

public final class IndeterminateState extends State<JProgressBar> {
    public IndeterminateState() {
        super("Indeterminate");
    }

    @Override
    protected boolean isInState(JProgressBar c) {
        return c.isIndeterminate();
    }
}

Represents a built in, or custom, state in Nimbus.

Synth provides several built in states, which are:

 Enabled
 Mouse Over
 Pressed
 Disabled
 Focused
 Selected
 Default


However, there are many more states that could be described in a LookAndFeel, and it
would be nice to style components differently based on these different states.
For example, a progress bar could be "indeterminate". It would be very convenient
to allow this to be defined as a "state".

This class, State, is intended to be used for such situations.
Simply implement the abstract #isInState method. It returns true if the given
JComponent is "in this state", false otherwise. This method will be called
many times in performance sensitive loops. It must execute
very quickly.

For example, the following might be an implementation of a custom
"Indeterminate" state for JProgressBars:



    public final class IndeterminateState extends State<JProgressBar> {
        public IndeterminateState() {
            super("Indeterminate");
        }

        @Override
        protected boolean isInState(JProgressBar c) {
            return c.isIndeterminate();
        }
    }