JProgressBar fills a percentage of its bar based on its
* current value. In indeterminate mode, it creates box and bounces it between
* its bounds.
* * This component has the following properties: *
*| Property | Stored in | Bound? |
|---|---|---|
| borderPainted | progressBar | yes |
| changeListeners | progressBar | no |
| indeterminate | progressBar | yes |
| maximum | model | no |
| minimum | model | no |
| model | progressBar | no |
| orientation | progressBar | yes |
| percentComplete | progressBar | no |
| string | progressBar | yes |
| stringPainted | progressBar | yes |
| value | model | no |
JProgressBar
* component.
*/
protected class AccessibleJProgressBar extends AccessibleJComponent
implements AccessibleValue
{
private static final long serialVersionUID = -2938130009392721813L;
/**
* Creates a new AccessibleJProgressBar instance.
*/
protected AccessibleJProgressBar()
{
// Nothing to do here.
}
/**
* Returns a set containing the current state of the {@link JProgressBar}
* component.
*
* @return The accessible state set.
*/
public AccessibleStateSet getAccessibleStateSet()
{
AccessibleStateSet result = super.getAccessibleStateSet();
if (orientation == JProgressBar.HORIZONTAL)
result.add(AccessibleState.HORIZONTAL);
else if (orientation == JProgressBar.VERTICAL)
result.add(AccessibleState.VERTICAL);
return result;
}
/**
* Returns the accessible role for the JProgressBar component.
*
* @return {@link AccessibleRole#PROGRESS_BAR}.
*/
public AccessibleRole getAccessibleRole()
{
return AccessibleRole.PROGRESS_BAR;
}
/**
* Returns an object that provides access to the current, minimum and
* maximum values.
*
* @return The accessible value.
*/
public AccessibleValue getAccessibleValue()
{
return this;
}
/**
* Returns the current value of the {@link JProgressBar} component, as an
* {@link Integer}.
*
* @return The current value of the {@link JProgressBar} component.
*/
public Number getCurrentAccessibleValue()
{
return new Integer(getValue());
}
/**
* Sets the current value of the {@link JProgressBar} component and sends a
* {@link PropertyChangeEvent} (with the property name
* {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
* listeners. If the supplied value is null, this method
* does nothing and returns false.
*
* @param value the new progress bar value (null permitted).
*
* @return true if the slider value is updated, and
* false otherwise.
*/
public boolean setCurrentAccessibleValue(Number value)
{
if (value == null)
return false;
Number oldValue = getCurrentAccessibleValue();
setValue(value.intValue());
firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue,
new Integer(getValue()));
return true;
}
/**
* Returns the minimum value of the {@link JProgressBar} component, as an
* {@link Integer}.
*
* @return The minimum value of the {@link JProgressBar} component.
*/
public Number getMinimumAccessibleValue()
{
return new Integer(getMinimum());
}
/**
* Returns the maximum value of the {@link JProgressBar} component, as an
* {@link Integer}.
*
* @return The maximum value of the {@link JProgressBar} component.
*/
public Number getMaximumAccessibleValue()
{
return new Integer(getMaximum());
}
}
private static final long serialVersionUID = 1980046021813598781L;
/**
* A flag that determines the mode (true for indeterminate,
* false for determinate).
*/
private transient boolean indeterminate = false;
/**
* The orientation of the JProgressBar
* ({@link SwingConstants#HORIZONTAL} or {@link SwingConstants#VERTICAL}).
* Defaults to {@link SwingConstants#HORIZONTAL}.
* @see #setOrientation(int)
*/
protected int orientation;
/**
* A flag the controls whether or not the component's border is painted.
* The default is true.
* @see #setBorderPainted(boolean)
*/
protected boolean paintBorder = true;
/**
* The model defining the bounds and current value for the progress bar.
* @see #setModel(BoundedRangeModel)
*/
protected BoundedRangeModel model;
/**
* A custom string for display in the progress bar. If this is
* null, a default string will be generated.
* @see #setString(String)
*/
protected String progressString;
/**
* A flag that controls whether a string is displayed within the progress
* bar.
* @see #setStringPainted(boolean)
*/
protected boolean paintString = false;
/**
* A single change event reused for all events.
* @see #fireStateChanged()
*/
protected transient ChangeEvent changeEvent;
/**
* The listener that is registered with the model. */
protected ChangeListener changeListener;
/**
* Creates a new JProgressBar with default attributes. The
* following defaults are used:
* *
value: 0;minimum: 0;maximum: 100;orientation: {@link SwingConstants#HORIZONTAL}.JProgressBar with the specified
* orientation. The following defaults are used:
* *
value: 0;minimum: 0;maximum: 100;orientation is not one of
* the specified values.
*/
public JProgressBar(int orientation)
{
this(orientation, 0, 100);
}
/**
* Creates a new JProgressBar with the specified value range.
* The following defaults are used:
* *
value: minimum;orientation: {@link SwingConstants#HORIZONTAL}.JProgressBar with the specified range and
* orientation. The following defaults are used:
* *
value: minimum;orientation is not one of
* the specified values.
*/
public JProgressBar(int orientation, int minimum, int maximum)
{
model = new DefaultBoundedRangeModel(minimum, 0, minimum, maximum);
if (orientation != HORIZONTAL && orientation != VERTICAL)
throw new IllegalArgumentException(orientation
+ " is not a legal orientation");
this.orientation = orientation;
changeListener = createChangeListener();
model.addChangeListener(changeListener);
updateUI();
}
/**
* Creates a new JProgressBar with the specified model. The
* following defaults are used:
* *
orientation: {@link SwingConstants#HORIZONTAL}.null not permitted).
*/
public JProgressBar(BoundedRangeModel model)
{
this.model = model;
changeListener = createChangeListener();
if (model != null)
model.addChangeListener(changeListener);
updateUI();
}
/**
* Returns the current value for the JProgressBar. This value
* is fetched from the model.
*
* @return The current value.
*
* @see #setValue(int)
*/
public int getValue()
{
return model.getValue();
}
/**
* Sets the current value for the JProgressBar. The value is
* stored in the component's model (see {@link #getModel()}).
* If the new value is different to the old value, a {@link ChangeEvent} is
* sent to the model's registered listeners. In turn, this triggers a call
* to {@link #fireStateChanged()} which will send a ChangeEvent
* to this component's registered listeners.
*
* If value is outside the range minimum to
* maximum, it will be set to the nearest of those boundary
* values.
*
* @param value the new value.
*
* @see #getValue()
*/
public void setValue(int value)
{
model.setValue(value);
}
/**
* Paints the component's border, but only if {@link #isBorderPainted()}
* returns true.
*
* @param graphics the graphics object to paint with.
*
* @see #setBorderPainted(boolean)
*/
protected void paintBorder(Graphics graphics)
{
Border border = getBorder();
if (paintBorder && border != null)
border.paintBorder(this, graphics, 0, 0, getWidth(), getHeight());
}
/**
* Returns the orientation of the JProgressBar component, which
* is either {@link SwingConstants#HORIZONTAL} or
* {@link SwingConstants#VERTICAL}. The default orientation is
* HORIZONTAL.
*
* @return The orientation.
*
* @see #setOrientation(int)
*/
public int getOrientation()
{
return orientation;
}
/**
* Sets the orientation for this JProgressBar component and,
* if the value changes, sends a {@link PropertyChangeEvent} (with the
* property name "orientation") to all registered listeners.
*
* @param orientation the orientation ({@link #HORIZONTAL} or
* {@link #VERTICAL}).
*
* @throws IllegalArgumentException if orientation is not
* one of the listed values.
*
* @see #getOrientation()
*/
public void setOrientation(int orientation)
{
if (orientation != VERTICAL && orientation != HORIZONTAL)
throw new IllegalArgumentException(orientation
+ " is not a legal orientation");
if (this.orientation != orientation)
{
int oldOrientation = this.orientation;
this.orientation = orientation;
firePropertyChange("orientation", oldOrientation, this.orientation);
}
}
/**
* Returns the flag that controls whether or not the string returned by
* {@link #getString()} is displayed by the JProgressBar
* component.
*
* @return true if the string should be displayed, and
* false otherwise.
*
* @see #setStringPainted(boolean)
*/
public boolean isStringPainted()
{
return paintString;
}
/**
* Sets the flag that controls whether or not the string returned by
* {@link #getString()} is displayed by the JProgressBar
* component. If the flag value changes, a {@link PropertyChangeEvent} (with
* the property name "stringPainted") is sent to all registered
* listeners.
*
* @param painted the new flag value.
*
* @see #isStringPainted()
* @see #setString(String)
*/
public void setStringPainted(boolean painted)
{
if (paintString != painted)
{
boolean oldPainted = paintString;
paintString = painted;
firePropertyChange("stringPainted", oldPainted, paintString);
}
}
/**
* Returns the string that is painted on the JProgressBar if
* {@link #isStringPainted()} returns true. If no string has
* been explicitly set, this method will return a string displaying the
* value of {@link #getPercentComplete()}.
*
* @return The string.
*
* @see #setString(String)
* @see #setStringPainted(boolean)
*/
public String getString()
{
if (progressString != null)
return progressString;
else
return (int) (getPercentComplete() * 100) + "%";
}
/**
* Sets the string to display within the progress bar and, if the new value
* is different to the old value, sends a {@link PropertyChangeEvent} (with
* the property name "string") to all registered listeners. If
* the string is set to null, {@link #getString()} will return
* a default string.
*
* @param string the string (null permitted).
*
* @see #getString()
* @see #setStringPainted(boolean)
*/
public void setString(String string)
{
if (((string == null || progressString == null) &&
string != progressString) || (string != null &&
! string.equals(progressString)))
{
String oldString = progressString;
progressString = string;
firePropertyChange("string", oldString, progressString);
}
}
/**
* Returns the current value expressed as a percentage. This is calculated
* as (value - min) / (max - min).
*
* @return The percentage (a value in the range 0.0 to 1.0).
*/
public double getPercentComplete()
{
if (getMaximum() == getMinimum())
return 1.0;
else
return (double) (model.getValue() - model.getMinimum())
/ (model.getMaximum() - model.getMinimum());
}
/**
* Returns a flag that controls whether or not the component's border is
* painted. The default value is true.
*
* @return true if the component's border should be painted,
* and false otherwise.
*
* @see #setBorderPainted(boolean)
*/
public boolean isBorderPainted()
{
return paintBorder;
}
/**
* Sets the flag that controls whether or not the component's border is
* painted. If the flag value is changed, this method sends a
* {@link PropertyChangeEvent} (with the property name "borderPainted") to
* all registered listeners.
*
* @param painted the new flag value.
*
* @see #isBorderPainted()
* @see #paintBorder
*/
public void setBorderPainted(boolean painted)
{
if (painted != paintBorder)
{
boolean oldPainted = paintBorder;
paintBorder = painted;
firePropertyChange("borderPainted", oldPainted, paintBorder);
}
}
/**
* Returns the UI delegate for this JProgressBar.
*
* @return The UI delegate.
*/
public ProgressBarUI getUI()
{
return (ProgressBarUI) ui;
}
/**
* Sets the UI delegate for this component.
*
* @param ui the new UI delegate.
*/
public void setUI(ProgressBarUI ui)
{
super.setUI(ui);
}
/**
* Sets this JProgressBar's UI delegate to the default
* (obtained from the {@link UIManager}) for the current look and feel.
*/
public void updateUI()
{
setUI((ProgressBarUI) UIManager.getUI(this));
}
/**
* Returns the suffix ("ProgressBarUI" in this case) used to
* determine the class name for a UI delegate that can provide the look and
* feel for a JProgressBar.
*
* @return "ProgressBarUI".
*/
public String getUIClassID()
{
return "ProgressBarUI";
}
/**
* Creates a new {@link ChangeListener} that calls
* {@link #fireStateChanged()} whenever it receives a {@link ChangeEvent}
* (typically from the component's model). This listener is
* registered with the progress bar's model, so that changes made to the
* model directly will automatically result in the progress bar's listeners
* being notified also.
*
* @return A new listener.
*/
protected ChangeListener createChangeListener()
{
return new ChangeListener()
{
public void stateChanged(ChangeEvent ce)
{
fireStateChanged();
}
};
}
/**
* Registers a listener with this component so that it will receive
* notification of component state changes.
*
* @param listener the listener.
*
* @see #removeChangeListener(ChangeListener)
*/
public void addChangeListener(ChangeListener listener)
{
listenerList.add(ChangeListener.class, listener);
}
/**
* Deregisters a listener so that it no longer receives notification of
* component state changes.
*
* @param listener the listener.
*
* @see #addChangeListener(ChangeListener)
*/
public void removeChangeListener(ChangeListener listener)
{
listenerList.remove(ChangeListener.class, listener);
}
/**
* Returns an array of the listeners that are registered with this component.
* The array may be empty, but is never null.
*
* @return An array of listeners.
*
* @since 1.4
*/
public ChangeListener[] getChangeListeners()
{
return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
}
/**
* Sends a {@link ChangeEvent} to all registered listeners to indicate that
* the state of the JProgressBar has changed.
*
* @see #createChangeListener()
*/
protected void fireStateChanged()
{
Object[] changeListeners = listenerList.getListenerList();
if (changeEvent == null)
changeEvent = new ChangeEvent(this);
for (int i = changeListeners.length - 2; i >= 0; i -= 2)
{
if (changeListeners[i] == ChangeListener.class)
((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
}
}
/**
* Returns the model for the JProgressBar.
*
* @return The model (never null).
*
* @see #setModel(BoundedRangeModel)
*/
public BoundedRangeModel getModel()
{
return model;
}
/**
* Sets the model for the JProgressBar and sends a
* {@link ChangeEvent} to all registered listeners.
*
* @param model the model (null not permitted).
*
* @see #getModel()
*/
public void setModel(BoundedRangeModel model)
{
if (model != this.model)
{
this.model.removeChangeListener(changeListener);
this.model = model;
this.model.addChangeListener(changeListener);
fireStateChanged();
}
}
/**
* Returns the minimum value for the JProgressBar. This defines
* the lower bound for the current value, and is stored in the component's
* model.
*
* @return The minimum value.
*
* @see #setMinimum(int)
*/
public int getMinimum()
{
return model.getMinimum();
}
/**
* Sets the minimum value for the JProgressBar. The value is
* stored in the component's model (see {@link #getModel()}).
* If the new value is different to the old value, a {@link ChangeEvent} is
* sent to the model's registered listeners. In turn, this triggers a call
* to {@link #fireStateChanged()} which will send a ChangeEvent
* to this component's registered listeners.
*
* @param minimum the minimum value.
*
* @see #getMinimum()
*/
public void setMinimum(int minimum)
{
model.setMinimum(minimum);
}
/**
* Returns the maximum value for the JProgressBar. This defines
* the upper bound for the current value, and is stored in the component's
* model.
*
* @return The maximum value.
*
* @see #setMaximum(int)
*/
public int getMaximum()
{
return model.getMaximum();
}
/**
* Sets the maximum value for the JProgressBar. The value is
* stored in the component's model (see {@link #getModel()}).
* If the new value is different to the old value, a {@link ChangeEvent} is
* sent to the model's registered listeners. In turn, this triggers a call
* to {@link #fireStateChanged()} which will send a ChangeEvent
* to this component's registered listeners.
*
* @param maximum the maximum value.
*
* @see #getMaximum()
*/
public void setMaximum(int maximum)
{
model.setMaximum(maximum);
}
/**
* Returns an implementation-dependent string describing the attributes of
* this JProgressBar.
*
* @return A string describing the attributes of this
* JProgressBar (never null).
*/
protected String paramString()
{
String superParamStr = super.paramString();
CPStringBuilder sb = new CPStringBuilder();
sb.append(",orientation=");
if (orientation == HORIZONTAL)
sb.append("HORIZONTAL");
else
sb.append("VERTICAL");
sb.append(",paintBorder=").append(isBorderPainted());
sb.append(",paintString=").append(isStringPainted());
sb.append(",progressString=");
if (progressString != null)
sb.append(progressString);
sb.append(",indeterminateString=").append(isIndeterminate());
return superParamStr + sb.toString();
}
/**
* Sets the flag that controls the mode for this JProgressBar
* (true for indeterminate mode, and false for
* determinate mode). If the flag value changes, this method sends a
* {@link PropertyChangeEvent} (with the property name
* "indeterminate") to all registered listeners.
*
* If the JProgressBar is determinate, it paints a percentage
* of the bar described by its value. If it is indeterminate, it simply
* bounces a box between the ends of the bar; the value of the
* JProgressBar is ignored.
*
* @param flag the new flag value.
*
* @see #isIndeterminate()
* @since 1.4
*/
public void setIndeterminate(boolean flag)
{
if (indeterminate != flag)
{
indeterminate = flag;
firePropertyChange("indeterminate", !flag, indeterminate);
}
}
/**
* Returns a flag that indicates the mode for this JProgressBar
* (true for indeterminate mode, and false for
* determinate mode).
*
* @return A flag indicating the mode for the JProgressBar.
*
* @see #setIndeterminate(boolean)
* @since 1.4
*/
public boolean isIndeterminate()
{
return indeterminate;
}
/**
* Returns the object that provides accessibility features for this
* JProgressBar component.
*
* @return The accessible context (an instance of
* {@link AccessibleJProgressBar}).
*/
public AccessibleContext getAccessibleContext()
{
if (accessibleContext == null)
accessibleContext = new AccessibleJProgressBar();
return accessibleContext;
}
}