Returns true if the specified x,y location is contained within the look and feel's defined shape of the specified component.

  Returns true if the specified x,y location is
contained within the look and feel's defined shape of the specified
component. x and y are defined to be relative
to the coordinate system of the specified component. Although
a component's bounds is constrained to a rectangle,
this method provides the means for defining a non-rectangular
shape within those bounds for the purpose of hit detection.
Parameters:
- c - the component where the x,y location is being queried; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
- x - the x coordinate of the point
- y - the y coordinate of the point
See Also: JComponent.contains(int, int), Component.contains(int, int),

  Returns the ith Accessible child of the object.

  Returns the ith Accessible child of the object. UIs might need to override this if they present areas on the screen that can be viewed as components, but actual components are not used for presenting those areas.

Note: As of v1.3, it is recommended that developers call Component.AccessibleAWTComponent.getAccessibleChild() instead of this method.
Returns: the ith Accessible child of the object
Parameters:
- i - zero-based index of child
See Also: ComponentUI.getAccessibleChildrenCount(javax.swing.JComponent),

  Returns the number of accessible children in the object.

  Returns the number of accessible children in the object. If all
of the children of this object implement Accessible,
this
method should return the number of children of this object.
UIs might wish to override this if they present areas on the
screen that can be viewed as components, but actual components
are not used for presenting those areas.

Note: As of v1.3, it is recommended that developers call
Component.AccessibleAWTComponent.getAccessibleChildrenCount() instead
of this method.
Returns: the number of accessible children in the object
See Also: ComponentUI.getAccessibleChild(javax.swing.JComponent, int),

  This determines the amount of the progress bar that should be filled based on the percent done gathered from the model.

  This determines the amount of the progress bar that should be filled
based on the percent done gathered from the model. This is a common
operation so it was abstracted out. It assumes that your progress bar
is linear. That is, if you are making a circular progress indicator,
you will want to override this method.

  Gets the index of the current animation frame.

  Gets the index of the current animation frame.
Since: 1.4

  Returns the baseline.

  Returns the baseline.
Throws:
- NullPointerException - {@inheritDoc}
- IllegalArgumentException - {@inheritDoc}
Since: 1.6
See Also: JComponent.getBaseline(int, int),

  Returns an enum indicating how the baseline of the component changes as the size changes.

  Returns an enum indicating how the baseline of the component
changes as the size changes.
Throws:
- NullPointerException - {@inheritDoc}
Since: 1.6
See Also: JComponent.getBaseline(int, int),

  Stores the position and size of the bouncing box that would be painted for the current animation index in r and returns r.

  Stores the position and size of
the bouncing box that would be painted for the current animation index
in r and returns r.
Subclasses that add to the painting performed
in this class's implementation of paintIndeterminate --
to draw an outline around the bouncing box, for example --
can use this method to get the location of the bouncing
box that was just painted.
By overriding this method,
you have complete control over the size and position
of the bouncing box,
without having to reimplement paintIndeterminate.
Returns: null if no box should be drawn; otherwise, returns the passed-in rectangle (if non-null) or a new rectangle
Parameters:
- r - the Rectangle instance to be modified; may be null
Since: 1.4
See Also: BasicProgressBarUI.setAnimationIndex(int),

  Returns the length of the "bouncing box" to be painted.

  Returns the length
of the "bouncing box" to be painted.
This method is invoked by the
default implementation of paintIndeterminate
to get the width (if the progress bar is horizontal)
or height (if vertical) of the box.
For example:

boxRect.width = getBoxLength(componentInnards.width,
                             componentInnards.height);
 

Returns: the size of the box dimension being determined; must be no larger than availableLength
Parameters:
- availableLength - the amount of space available for the bouncing box to move in; for a horizontal progress bar, for example, this should be the inside width of the progress bar (the component width minus borders)
- otherDimension - for a horizontal progress bar, this should be the inside height of the progress bar; this value might be used to constrain or determine the return value
Since: 1.5
See Also: SwingUtilities.calculateInnerArea(javax.swing.JComponent, java.awt.Rectangle),

  Returns the width (if HORIZONTAL) or height (if VERTICAL) of each of the indivdual cells/units to be rendered in the progress bar.

  Returns the width (if HORIZONTAL) or height (if VERTICAL)
of each of the indivdual cells/units to be rendered in the
progress bar. However, for text rendering simplification and
aesthetic considerations, this function will return 1 when
the progress string is being rendered.
Returns: the value representing the spacing between cells
See Also: BasicProgressBarUI.setCellLength(int), JProgressBar.isStringPainted(),

  Returns the spacing between each of the cells/units in the progress bar.

  Returns the spacing between each of the cells/units in the
progress bar. However, for text rendering simplification and
aesthetic considerations, this function will return 0 when
the progress string is being rendered.
Returns: the value representing the spacing between cells
See Also: BasicProgressBarUI.setCellSpacing(int), JProgressBar.isStringPainted(),

  Returns the number of frames for the complete animation loop used by an indeterminate JProgessBar.

  Returns the number of frames for the complete animation loop
used by an indeterminate JProgessBar. The progress chunk will go
from one end to the other and back during the entire loop. This
visual behavior may be changed by subclasses in other Look and Feels.
Returns: the number of frames
Since: 1.6

  The Minimum size for this component is 10.

  The Minimum size for this component is 10. The rationale here
is that there should be at least one pixel per 10 percent.

The "selectionBackground" is the color of the text when it is painted over an unfilled area of the progress bar.

The "selectionForeground" is the color of the text when it is painted over a filled area of the progress bar.

  Designate the place where the progress string will be painted.

  Designate the place where the progress string will be painted.
This implementation places it at the center of the progress
bar (in both x and y). Override this if you want to right,
left, top, or bottom align the progress string or if you need
to nudge it around for any reason.

  Sets the index of the current animation frame, to the next valid value, which results in the progress bar being repainted.

  Sets the index of the current animation frame,
to the next valid value,
which results in the progress bar being repainted.
The next valid value is, by default,
the current animation index plus one.
If the new value would be too large,
this method sets the index to 0.
Subclasses might need to override this method
to ensure that the index does not go over
the number of frames needed for the particular
progress bar instance.
This method is invoked by the default animation thread
every X milliseconds,
where X is specified by the "ProgressBar.repaintInterval"
UI default.
Since: 1.4
See Also: BasicProgressBarUI.setAnimationIndex(int),

Delegates painting to one of two methods: paintDeterminate or paintIndeterminate.

  Sets the index of the current animation frame to the specified value and requests that the progress bar be repainted.

  Sets the index of the current animation frame
to the specified value and requests that the
progress bar be repainted.
Subclasses that don't use the default painting code
might need to override this method
to change the way that the repaint method
is invoked.
Parameters:
- newValue - the new animation index; no checking is performed on its value
Since: 1.4
See Also: BasicProgressBarUI.incrementAnimationIndex(),

  Starts the animation thread, creating and initializing it if necessary.

  Starts the animation thread, creating and initializing
it if necessary. This method is invoked when an
indeterminate progress bar should start animating.
Reasons for this may include:

• The progress bar is determinate and becomes displayable
  
• The progress bar is displayable and becomes determinate
  
• The progress bar is displayable and determinate and this
  UI is installed
  

If you implement your own animation thread,
you must override this method.
Since: 1.4
See Also: BasicProgressBarUI.stopAnimationTimer(),

  Stops the animation thread.

  Stops the animation thread.
This method is invoked when the indeterminate
animation should be stopped. Reasons for this may include:

• The progress bar changes to determinate
  
• The progress bar is no longer part of a displayable hierarchy
  
• This UI in uninstalled
  

If you implement your own animation thread,
you must override this method.
Since: 1.4
See Also: BasicProgressBarUI.startAnimationTimer(),

Removes all listeners installed by this object.

  Notifies this UI delegate that it's time to paint the specified component.

  Notifies this UI delegate that it's time to paint the specified
component. This method is invoked by JComponent
when the specified component is being painted.
By default this method will fill the specified component with
its background color (if its opaque property is
true) and then immediately call paint.
In general this method need not be overridden by subclasses;
all look-and-feel rendering code should reside in the paint
method.
Parameters:
- g - the Graphics context in which to paint
- c - the component being painted; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
See Also: ComponentUI.paint(java.awt.Graphics, javax.swing.JComponent), JComponent.paintComponent(java.awt.Graphics),