Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing;

	import java.awt.Color;
	import java.awt.Graphics;

	import java.text.Format;
	import java.text.NumberFormat;

	import java.io.Serializable;
	import java.io.ObjectOutputStream;
	import java.io.ObjectInputStream;
	import java.io.IOException;

	import javax.swing.event.*;
	import javax.accessibility.*;
	import javax.swing.plaf.ProgressBarUI;


	/**
	* A component that visually displays the progress of some task. As the task
	* progresses towards completion, the progress bar displays the
	* task's percentage of completion.
	* This percentage is typically represented visually by a rectangle which
	* starts out empty and gradually becomes filled in as the task progresses.
	* In addition, the progress bar can display a textual representation of this
	* percentage.
	* <p>
	* {@code JProgressBar} uses a {@code BoundedRangeModel} as its data model,
	* with the {@code value} property representing the "current" state of the task,
	* and the {@code minimum} and {@code maximum} properties representing the
	* beginning and end points, respectively.
	* <p>
	* To indicate that a task of unknown length is executing,
	* you can put a progress bar into indeterminate mode.
	* While the bar is in indeterminate mode,
	* it animates constantly to show that work is occurring.
	* As soon as you can determine the task's length and amount of progress,
	* you should update the progress bar's value
	* and switch it back to determinate mode.
	*
	* <p>
	*
	* Here is an example of creating a progress bar,
	* where <code>task</code> is an object (representing some piece of work)
	* which returns information about the progress of the task:
	*
	*<pre>
	*progressBar = new JProgressBar(0, task.getLengthOfTask());
	*progressBar.setValue(0);
	*progressBar.setStringPainted(true);
	*</pre>
	*
	* Here is an example of querying the current state of the task, and using
	* the returned value to update the progress bar:
	*
	*<pre>
	*progressBar.setValue(task.getCurrent());
	*</pre>
	*
	* Here is an example of putting a progress bar into
	* indeterminate mode,
	* and then switching back to determinate mode
	* once the length of the task is known:
	*
	*<pre>
	*progressBar = new JProgressBar();
	*<em>...//when the task of (initially) unknown length begins:</em>
	*progressBar.setIndeterminate(true);
	*<em>...//do some work; get length of task...</em>
	*progressBar.setMaximum(newLength);
	*progressBar.setValue(newValue);
	*progressBar.setIndeterminate(false);
	*</pre>
	*
	* <p>
	*
	* For complete examples and further documentation see
	* <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/progress.html" target="_top">How to Monitor Progress</a>,
	* a section in <em>The Java Tutorial.</em>
	*
	* <p>
	* <strong>Warning:</strong> Swing is not thread safe. For more
	* information see <a
	* href="package-summary.html#threading">Swing's Threading
	* Policy</a>.
	* <p>
	* <strong>Warning:</strong>
	* 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 <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @see javax.swing.plaf.basic.BasicProgressBarUI
	* @see javax.swing.BoundedRangeModel
	* @see javax.swing.SwingWorker
	*
	* @beaninfo
	* attribute: isContainer false
	* description: A component that displays an integer value.
	*
	* @author Michael C. Albers
	* @author Kathy Walrath
	*/
	public class JProgressBar extends JComponent implements SwingConstants, Accessible
	{
	/**
	* @see #getUIClassID
	*/
	private static final String uiClassID = "ProgressBarUI";

	/**
	* Whether the progress bar is horizontal or vertical.
	* The default is <code>HORIZONTAL</code>.
	*
	* @see #setOrientation
	*/
	protected int orientation;

	/**
	* Whether to display a border around the progress bar.
	* The default is <code>true</code>.
	*
	* @see #setBorderPainted
	*/
	protected boolean paintBorder;

	/**
	* The object that holds the data for the progress bar.
	*
	* @see #setModel
	*/
	protected BoundedRangeModel model;

	/**
	* An optional string that can be displayed on the progress bar.
	* The default is <code>null</code>. Setting this to a non-<code>null</code>
	* value does not imply that the string will be displayed.
	* To display the string, {@code paintString} must be {@code true}.
	*
	* @see #setString
	* @see #setStringPainted
	*/
	protected String progressString;

	/**
	* Whether to display a string of text on the progress bar.
	* The default is <code>false</code>.
	* Setting this to <code>true</code> causes a textual
	* display of the progress to be rendered on the progress bar. If
	* the <code>progressString</code> is <code>null</code>,
	* the percentage of completion is displayed on the progress bar.
	* Otherwise, the <code>progressString</code> is
	* rendered on the progress bar.
	*
	* @see #setStringPainted
	* @see #setString
	*/
	protected boolean paintString;

	/**
	* The default minimum for a progress bar is 0.
	*/
	static final private int defaultMinimum = 0;
	/**
	* The default maximum for a progress bar is 100.
	*/
	static final private int defaultMaximum = 100;
	/**
	* The default orientation for a progress bar is <code>HORIZONTAL</code>.
	*/
	static final private int defaultOrientation = HORIZONTAL;

	/**
	* Only one <code>ChangeEvent</code> is needed per instance since the
	* event's only interesting property is the immutable source, which
	* is the progress bar.
	* The event is lazily created the first time that an
	* event notification is fired.
	*
	* @see #fireStateChanged
	*/
	protected transient ChangeEvent changeEvent = null;

	/**
	* Listens for change events sent by the progress bar's model,
	* redispatching them
	* to change-event listeners registered upon
	* this progress bar.
	*
	* @see #createChangeListener
	*/
	protected ChangeListener changeListener = null;

	/**
	* Format used when displaying percent complete.
	*/
	private transient Format format;

	/**
	* Whether the progress bar is indeterminate (<code>true</code>) or
	* normal (<code>false</code>); the default is <code>false</code>.
	*
	* @see #setIndeterminate
	* @since 1.4
	*/
	private boolean indeterminate;


	/**
	* Creates a horizontal progress bar
	* that displays a border but no progress string.
	* The initial and minimum values are 0,
	* and the maximum is 100.
	*
	* @see #setOrientation
	* @see #setBorderPainted
	* @see #setStringPainted
	* @see #setString
	* @see #setIndeterminate
	*/
	public JProgressBar()
	{
	this(defaultOrientation);
	}

	/**
	* Creates a progress bar with the specified orientation,
	* which can be
	* either {@code SwingConstants.VERTICAL} or
	* {@code SwingConstants.HORIZONTAL}.
	* By default, a border is painted but a progress string is not.
	* The initial and minimum values are 0,
	* and the maximum is 100.
	*
	* @param orient the desired orientation of the progress bar
	* @throws IllegalArgumentException if {@code orient} is an illegal value
	*
	* @see #setOrientation
	* @see #setBorderPainted
	* @see #setStringPainted
	* @see #setString
	* @see #setIndeterminate
	*/
	public JProgressBar(int orient)
	{
	this(orient, defaultMinimum, defaultMaximum);
	}


	/**
	* Creates a horizontal progress bar
	* with the specified minimum and maximum.
	* Sets the initial value of the progress bar to the specified minimum.
	* By default, a border is painted but a progress string is not.
	* <p>
	* The <code>BoundedRangeModel</code> that holds the progress bar's data
	* handles any issues that may arise from improperly setting the
	* minimum, initial, and maximum values on the progress bar.
	* See the {@code BoundedRangeModel} documentation for details.
	*
	* @param min the minimum value of the progress bar
	* @param max the maximum value of the progress bar
	*
	* @see BoundedRangeModel
	* @see #setOrientation
	* @see #setBorderPainted
	* @see #setStringPainted
	* @see #setString
	* @see #setIndeterminate
	*/
	public JProgressBar(int min, int max)
	{
	this(defaultOrientation, min, max);
	}


	/**
	* Creates a progress bar using the specified orientation,
	* minimum, and maximum.
	* By default, a border is painted but a progress string is not.
	* Sets the initial value of the progress bar to the specified minimum.
	* <p>
	* The <code>BoundedRangeModel</code> that holds the progress bar's data
	* handles any issues that may arise from improperly setting the
	* minimum, initial, and maximum values on the progress bar.
	* See the {@code BoundedRangeModel} documentation for details.
	*
	* @param orient the desired orientation of the progress bar
	* @param min the minimum value of the progress bar
	* @param max the maximum value of the progress bar
	* @throws IllegalArgumentException if {@code orient} is an illegal value
	*
	* @see BoundedRangeModel
	* @see #setOrientation
	* @see #setBorderPainted
	* @see #setStringPainted
	* @see #setString
	* @see #setIndeterminate
	*/
	public JProgressBar(int orient, int min, int max)
	{
	// Creating the model this way is a bit simplistic, but
	// I believe that it is the the most common usage of this
	// component - it's what people will expect.
	setModel(new DefaultBoundedRangeModel(min, 0, min, max));
	updateUI();

	setOrientation(orient); // documented with set/getOrientation()
	setBorderPainted(true); // documented with is/setBorderPainted()
	setStringPainted(false); // see setStringPainted
	setString(null); // see getString
	setIndeterminate(false); // see setIndeterminate
	}


	/**
	* Creates a horizontal progress bar
	* that uses the specified model
	* to hold the progress bar's data.
	* By default, a border is painted but a progress string is not.
	*
	* @param newModel the data model for the progress bar
	*
	* @see #setOrientation
	* @see #setBorderPainted
	* @see #setStringPainted
	* @see #setString
	* @see #setIndeterminate
	*/
	public JProgressBar(BoundedRangeModel newModel)
	{
	setModel(newModel);
	updateUI();

	setOrientation(defaultOrientation); // see setOrientation()
	setBorderPainted(true); // see setBorderPainted()
	setStringPainted(false); // see setStringPainted
	setString(null); // see getString
	setIndeterminate(false); // see setIndeterminate
	}


	/**
	* Returns {@code SwingConstants.VERTICAL} or
	* {@code SwingConstants.HORIZONTAL}, depending on the orientation
	* of the progress bar. The default orientation is
	* {@code SwingConstants.HORIZONTAL}.
	*
	* @return <code>HORIZONTAL</code> or <code>VERTICAL</code>
	* @see #setOrientation
	*/
	public int getOrientation() {
	return orientation;
	}


	/**
	* Sets the progress bar's orientation to <code>newOrientation</code>,
	* which must be {@code SwingConstants.VERTICAL} or
	* {@code SwingConstants.HORIZONTAL}. The default orientation
	* is {@code SwingConstants.HORIZONTAL}.
	*
	* @param newOrientation <code>HORIZONTAL</code> or <code>VERTICAL</code>
	* @exception IllegalArgumentException if <code>newOrientation</code>
	* is an illegal value
	* @see #getOrientation
	*
	* @beaninfo
	* preferred: true
	* bound: true
	* attribute: visualUpdate true
	* description: Set the progress bar's orientation.
	*/
	public void setOrientation(int newOrientation) {
	if (orientation != newOrientation) {
	switch (newOrientation) {
	case VERTICAL:
	case HORIZONTAL:
	int oldOrientation = orientation;
	orientation = newOrientation;
	firePropertyChange("orientation", oldOrientation, newOrientation);
	if (accessibleContext != null) {
	accessibleContext.firePropertyChange(
	AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
	((oldOrientation == VERTICAL)
	? AccessibleState.VERTICAL
	: AccessibleState.HORIZONTAL),
	((orientation == VERTICAL)
	? AccessibleState.VERTICAL
	: AccessibleState.HORIZONTAL));
	}
	break;
	default:
	throw new IllegalArgumentException(newOrientation +
	" is not a legal orientation");
	}
	revalidate();
	}
	}


	/**
	* Returns the value of the <code>stringPainted</code> property.
	*
	* @return the value of the <code>stringPainted</code> property
	* @see #setStringPainted
	* @see #setString
	*/
	public boolean isStringPainted() {
	return paintString;
	}


	/**
	* Sets the value of the <code>stringPainted</code> property,
	* which determines whether the progress bar
	* should render a progress string.
	* The default is <code>false</code>, meaning
	* no string is painted.
	* Some look and feels might not support progress strings
	* or might support them only when the progress bar is in determinate mode.
	*
	* @param b <code>true</code> if the progress bar should render a string
	* @see #isStringPainted
	* @see #setString
	* @beaninfo
	* bound: true
	* attribute: visualUpdate true
	* description: Whether the progress bar should render a string.
	*/
	public void setStringPainted(boolean b) {
	//PENDING: specify that string not painted when in indeterminate mode?
	// or just leave that to the L&F?
	boolean oldValue = paintString;
	paintString = b;
	firePropertyChange("stringPainted", oldValue, paintString);
	if (paintString != oldValue) {
	revalidate();
	repaint();
	}
	}


	/**
	* Returns a {@code String} representation of the current progress.
	* By default, this returns a simple percentage {@code String} based on
	* the value returned from {@code getPercentComplete}. An example
	* would be the "42%". You can change this by calling {@code setString}.
	*
	* @return the value of the progress string, or a simple percentage string
	* if the progress string is {@code null}
	* @see #setString
	*/
	public String getString(){
	if (progressString != null) {
	return progressString;
	} else {
	if (format == null) {
	format = NumberFormat.getPercentInstance();
	}
	return format.format(new Double(getPercentComplete()));
	}
	}

	/**
	* Sets the value of the progress string. By default,
	* this string is <code>null</code>, implying the built-in behavior of
	* using a simple percent string.
	* If you have provided a custom progress string and want to revert to
	* the built-in behavior, set the string back to <code>null</code>.
	* <p>
	* The progress string is painted only if
	* the <code>isStringPainted</code> method returns <code>true</code>.
	*
	* @param s the value of the progress string
	* @see #getString
	* @see #setStringPainted
	* @see #isStringPainted
	* @beaninfo
	* bound: true
	* attribute: visualUpdate true
	* description: Specifies the progress string to paint
	*/
	public void setString(String s){
	String oldValue = progressString;
	progressString = s;
	firePropertyChange("string", oldValue, progressString);
	if (progressString == null \|\| oldValue == null \|\| !progressString.equals(oldValue)) {
	repaint();
	}
	}

	/**
	* Returns the percent complete for the progress bar.
	* Note that this number is between 0.0 and 1.0.
	*
	* @return the percent complete for this progress bar
	*/
	public double getPercentComplete() {
	long span = model.getMaximum() - model.getMinimum();
	double currentValue = model.getValue();
	double pc = (currentValue - model.getMinimum()) / span;
	return pc;
	}

	/**
	* Returns the <code>borderPainted</code> property.
	*
	* @return the value of the <code>borderPainted</code> property
	* @see #setBorderPainted
	* @beaninfo
	* description: Does the progress bar paint its border
	*/
	public boolean isBorderPainted() {
	return paintBorder;
	}

	/**
	* Sets the <code>borderPainted</code> property, which is
	* <code>true</code> if the progress bar should paint its border.
	* The default value for this property is <code>true</code>.
	* Some look and feels might not implement painted borders;
	* they will ignore this property.
	*
	* @param b <code>true</code> if the progress bar
	* should paint its border;
	* otherwise, <code>false</code>
	* @see #isBorderPainted
	* @beaninfo
	* bound: true
	* attribute: visualUpdate true
	* description: Whether the progress bar should paint its border.
	*/
	public void setBorderPainted(boolean b) {
	boolean oldValue = paintBorder;
	paintBorder = b;
	firePropertyChange("borderPainted", oldValue, paintBorder);
	if (paintBorder != oldValue) {
	repaint();
	}
	}

	/**
	* Paints the progress bar's border if the <code>borderPainted</code>
	* property is <code>true</code>.
	*
	* @param g the <code>Graphics</code> context within which to paint the border
	* @see #paint
	* @see #setBorder
	* @see #isBorderPainted
	* @see #setBorderPainted
	*/
	protected void paintBorder(Graphics g) {
	if (isBorderPainted()) {
	super.paintBorder(g);
	}
	}


	/**
	* Returns the look-and-feel object that renders this component.
	*
	* @return the <code>ProgressBarUI</code> object that renders this component
	*/
	public ProgressBarUI getUI() {
	return (ProgressBarUI)ui;
	}

	/**
	* Sets the look-and-feel object that renders this component.
	*
	* @param ui a <code>ProgressBarUI</code> object
	* @see UIDefaults#getUI
	* @beaninfo
	* bound: true
	* hidden: true
	* attribute: visualUpdate true
	* description: The UI object that implements the Component's LookAndFeel.
	*/
	public void setUI(ProgressBarUI ui) {
	super.setUI(ui);
	}


	/**
	* Resets the UI property to a value from the current look and feel.
	*
	* @see JComponent#updateUI
	*/
	public void updateUI() {
	setUI((ProgressBarUI)UIManager.getUI(this));
	}


	/**
	* Returns the name of the look-and-feel class that renders this component.
	*
	* @return the string "ProgressBarUI"
	* @see JComponent#getUIClassID
	* @see UIDefaults#getUI
	* @beaninfo
	* expert: true
	* description: A string that specifies the name of the look-and-feel class.
	*/
	public String getUIClassID() {
	return uiClassID;
	}


	/* We pass each Change event to the listeners with the
	* the progress bar as the event source.
	* <p>
	* <strong>Warning:</strong>
	* 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 <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*/
	private class ModelListener implements ChangeListener, Serializable {
	public void stateChanged(ChangeEvent e) {
	fireStateChanged();
	}
	}

	/**
	* Subclasses that want to handle change events
	* from the model differently
	* can override this to return
	* an instance of a custom <code>ChangeListener</code> implementation.
	* The default {@code ChangeListener} simply calls the
	* {@code fireStateChanged} method to forward {@code ChangeEvent}s
	* to the {@code ChangeListener}s that have been added directly to the
	* progress bar.
	*
	* @see #changeListener
	* @see #fireStateChanged
	* @see javax.swing.event.ChangeListener
	* @see javax.swing.BoundedRangeModel
	*/
	protected ChangeListener createChangeListener() {
	return new ModelListener();
	}

	/**
	* Adds the specified <code>ChangeListener</code> to the progress bar.
	*
	* @param l the <code>ChangeListener</code> to add
	*/
	public void addChangeListener(ChangeListener l) {
	listenerList.add(ChangeListener.class, l);
	}

	/**
	* Removes a <code>ChangeListener</code> from the progress bar.
	*
	* @param l the <code>ChangeListener</code> to remove
	*/
	public void removeChangeListener(ChangeListener l) {
	listenerList.remove(ChangeListener.class, l);
	}

	/**
	* Returns an array of all the <code>ChangeListener</code>s added
	* to this progress bar with <code>addChangeListener</code>.
	*
	* @return all of the <code>ChangeListener</code>s added or an empty
	* array if no listeners have been added
	* @since 1.4
	*/
	public ChangeListener[] getChangeListeners() {
	return listenerList.getListeners(ChangeListener.class);
	}

	/**
	* Send a {@code ChangeEvent}, whose source is this {@code JProgressBar}, to
	* all {@code ChangeListener}s that have registered interest in
	* {@code ChangeEvent}s.
	* This method is called each time a {@code ChangeEvent} is received from
	* the model.
	* <p>
	*
	* The event instance is created if necessary, and stored in
	* {@code changeEvent}.
	*
	* @see #addChangeListener
	* @see EventListenerList
	*/
	protected void fireStateChanged() {
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length-2; i>=0; i-=2) {
	if (listeners[i]==ChangeListener.class) {
	// Lazily create the event:
	if (changeEvent == null)
	changeEvent = new ChangeEvent(this);
	((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
	}
	}
	}

	/**
	* Returns the data model used by this progress bar.
	*
	* @return the <code>BoundedRangeModel</code> currently in use
	* @see #setModel
	* @see BoundedRangeModel
	*/
	public BoundedRangeModel getModel() {
	return model;
	}

	/**
	* Sets the data model used by the <code>JProgressBar</code>.
	* Note that the {@code BoundedRangeModel}'s {@code extent} is not used,
	* and is set to {@code 0}.
	*
	* @param newModel the <code>BoundedRangeModel</code> to use
	*
	* @beaninfo
	* expert: true
	* description: The data model used by the JProgressBar.
	*/
	public void setModel(BoundedRangeModel newModel) {
	// PENDING(???) setting the same model to multiple bars is broken; listeners
	BoundedRangeModel oldModel = getModel();

	if (newModel != oldModel) {
	if (oldModel != null) {
	oldModel.removeChangeListener(changeListener);
	changeListener = null;
	}

	model = newModel;

	if (newModel != null) {
	changeListener = createChangeListener();
	newModel.addChangeListener(changeListener);
	}

	if (accessibleContext != null) {
	accessibleContext.firePropertyChange(
	AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
	(oldModel== null
	? null : Integer.valueOf(oldModel.getValue())),
	(newModel== null
	? null : Integer.valueOf(newModel.getValue())));
	}

	if (model != null) {
	model.setExtent(0);
	}
	repaint();
	}
	}


	/* All of the model methods are implemented by delegation. */

	/**
	* Returns the progress bar's current {@code value}
	* from the <code>BoundedRangeModel</code>.
	* The value is always between the
	* minimum and maximum values, inclusive.
	*
	* @return the current value of the progress bar
	* @see #setValue
	* @see BoundedRangeModel#getValue
	*/
	public int getValue() { return getModel().getValue(); }

	/**
	* Returns the progress bar's {@code minimum} value
	* from the <code>BoundedRangeModel</code>.
	*
	* @return the progress bar's minimum value
	* @see #setMinimum
	* @see BoundedRangeModel#getMinimum
	*/
	public int getMinimum() { return getModel().getMinimum(); }

	/**
	* Returns the progress bar's {@code maximum} value
	* from the <code>BoundedRangeModel</code>.
	*
	* @return the progress bar's maximum value
	* @see #setMaximum
	* @see BoundedRangeModel#getMaximum
	*/
	public int getMaximum() { return getModel().getMaximum(); }

	/**
	* Sets the progress bar's current value to {@code n}. This method
	* forwards the new value to the model.
	* <p>
	* The data model (an instance of {@code BoundedRangeModel})
	* handles any mathematical
	* issues arising from assigning faulty values. See the
	* {@code BoundedRangeModel} documentation for details.
	* <p>
	* If the new value is different from the previous value,
	* all change listeners are notified.
	*
	* @param n the new value
	* @see #getValue
	* @see #addChangeListener
	* @see BoundedRangeModel#setValue
	* @beaninfo
	* preferred: true
	* description: The progress bar's current value.
	*/
	public void setValue(int n) {
	BoundedRangeModel brm = getModel();
	int oldValue = brm.getValue();
	brm.setValue(n);

	if (accessibleContext != null) {
	accessibleContext.firePropertyChange(
	AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
	Integer.valueOf(oldValue),
	Integer.valueOf(brm.getValue()));
	}
	}

	/**
	* Sets the progress bar's minimum value
	* (stored in the progress bar's data model) to <code>n</code>.
	* <p>
	* The data model (a <code>BoundedRangeModel</code> instance)
	* handles any mathematical
	* issues arising from assigning faulty values.
	* See the {@code BoundedRangeModel} documentation for details.
	* <p>
	* If the minimum value is different from the previous minimum,
	* all change listeners are notified.
	*
	* @param n the new minimum
	* @see #getMinimum
	* @see #addChangeListener
	* @see BoundedRangeModel#setMinimum
	* @beaninfo
	* preferred: true
	* description: The progress bar's minimum value.
	*/
	public void setMinimum(int n) { getModel().setMinimum(n); }

	/**
	* Sets the progress bar's maximum value
	* (stored in the progress bar's data model) to <code>n</code>.
	* <p>
	* The underlying <code>BoundedRangeModel</code> handles any mathematical
	* issues arising from assigning faulty values.
	* See the {@code BoundedRangeModel} documentation for details.
	* <p>
	* If the maximum value is different from the previous maximum,
	* all change listeners are notified.
	*
	* @param n the new maximum
	* @see #getMaximum
	* @see #addChangeListener
	* @see BoundedRangeModel#setMaximum
	* @beaninfo
	* preferred: true
	* description: The progress bar's maximum value.
	*/
	public void setMaximum(int n) { getModel().setMaximum(n); }

	/**
	* Sets the <code>indeterminate</code> property of the progress bar,
	* which determines whether the progress bar is in determinate
	* or indeterminate mode.
	* An indeterminate progress bar continuously displays animation
	* indicating that an operation of unknown length is occurring.
	* By default, this property is <code>false</code>.
	* Some look and feels might not support indeterminate progress bars;
	* they will ignore this property.
	*
	* <p>
	*
	* See
	* <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/progress.html" target="_top">How to Monitor Progress</a>
	* for examples of using indeterminate progress bars.
	*
	* @param newValue <code>true</code> if the progress bar
	* should change to indeterminate mode;
	* <code>false</code> if it should revert to normal.
	*
	* @see #isIndeterminate
	* @see javax.swing.plaf.basic.BasicProgressBarUI
	*
	* @since 1.4
	*
	* @beaninfo
	* bound: true
	* attribute: visualUpdate true
	* description: Set whether the progress bar is indeterminate (true)
	* or normal (false).
	*/
	public void setIndeterminate(boolean newValue) {
	boolean oldValue = indeterminate;
	indeterminate = newValue;
	firePropertyChange("indeterminate", oldValue, indeterminate);
	}

	/**
	* Returns the value of the <code>indeterminate</code> property.
	*
	* @return the value of the <code>indeterminate</code> property
	* @see #setIndeterminate
	*
	* @since 1.4
	*
	* @beaninfo
	* description: Is the progress bar indeterminate (true)
	* or normal (false)?
	*/
	public boolean isIndeterminate() {
	return indeterminate;
	}


	/**
	* See readObject() and writeObject() in JComponent for more
	* information about serialization in Swing.
	*/
	private void writeObject(ObjectOutputStream s) throws IOException {
	s.defaultWriteObject();
	if (getUIClassID().equals(uiClassID)) {
	byte count = JComponent.getWriteObjCounter(this);
	JComponent.setWriteObjCounter(this, --count);
	if (count == 0 && ui != null) {
	ui.installUI(this);
	}
	}
	}


	/**
	* Returns a string representation of this <code>JProgressBar</code>.
	* This method is intended to be used only for debugging purposes. The
	* content and format of the returned string may vary between
	* implementations. The returned string may be empty but may not
	* be <code>null</code>.
	*
	* @return a string representation of this <code>JProgressBar</code>
	*/
	protected String paramString() {
	String orientationString = (orientation == HORIZONTAL ?
	"HORIZONTAL" : "VERTICAL");
	String paintBorderString = (paintBorder ?
	"true" : "false");
	String progressStringString = (progressString != null ?
	progressString : "");
	String paintStringString = (paintString ?
	"true" : "false");
	String indeterminateString = (indeterminate ?
	"true" : "false");

	return super.paramString() +
	",orientation=" + orientationString +
	",paintBorder=" + paintBorderString +
	",paintString=" + paintStringString +
	",progressString=" + progressStringString +
	",indeterminateString=" + indeterminateString;
	}

	/////////////////
	// Accessibility support
	////////////////

	/**
	* Gets the <code>AccessibleContext</code> associated with this
	* <code>JProgressBar</code>. For progress bars, the
	* <code>AccessibleContext</code> takes the form of an
	* <code>AccessibleJProgressBar</code>.
	* A new <code>AccessibleJProgressBar</code> instance is created if necessary.
	*
	* @return an <code>AccessibleJProgressBar</code> that serves as the
	* <code>AccessibleContext</code> of this <code>JProgressBar</code>
	* @beaninfo
	* expert: true
	* description: The AccessibleContext associated with this ProgressBar.
	*/
	public AccessibleContext getAccessibleContext() {
	if (accessibleContext == null) {
	accessibleContext = new AccessibleJProgressBar();
	}
	return accessibleContext;
	}

	/**
	* This class implements accessibility support for the
	* <code>JProgressBar</code> class. It provides an implementation of the
	* Java Accessibility API appropriate to progress bar user-interface
	* elements.
	* <p>
	* <strong>Warning:</strong>
	* 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 <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*/
	protected class AccessibleJProgressBar extends AccessibleJComponent
	implements AccessibleValue {

	/**
	* Gets the state set of this object.
	*
	* @return an instance of AccessibleState containing the current state
	* of the object
	* @see AccessibleState
	*/
	public AccessibleStateSet getAccessibleStateSet() {
	AccessibleStateSet states = super.getAccessibleStateSet();
	if (getModel().getValueIsAdjusting()) {
	states.add(AccessibleState.BUSY);
	}
	if (getOrientation() == VERTICAL) {
	states.add(AccessibleState.VERTICAL);
	} else {
	states.add(AccessibleState.HORIZONTAL);
	}
	return states;
	}

	/**
	* Gets the role of this object.
	*
	* @return an instance of AccessibleRole describing the role of the
	* object
	*/
	public AccessibleRole getAccessibleRole() {
	return AccessibleRole.PROGRESS_BAR;
	}

	/**
	* Gets the <code>AccessibleValue</code> associated with this object. In the
	* implementation of the Java Accessibility API for this class,
	* returns this object, which is responsible for implementing the
	* <code>AccessibleValue</code> interface on behalf of itself.
	*
	* @return this object
	*/
	public AccessibleValue getAccessibleValue() {
	return this;
	}

	/**
	* Gets the accessible value of this object.
	*
	* @return the current value of this object
	*/
	public Number getCurrentAccessibleValue() {
	return Integer.valueOf(getValue());
	}

	/**
	* Sets the value of this object as a <code>Number</code>.
	*
	* @return <code>true</code> if the value was set
	*/
	public boolean setCurrentAccessibleValue(Number n) {
	// TIGER- 4422535
	if (n == null) {
	return false;
	}
	setValue(n.intValue());
	return true;
	}

	/**
	* Gets the minimum accessible value of this object.
	*
	* @return the minimum value of this object
	*/
	public Number getMinimumAccessibleValue() {
	return Integer.valueOf(getMinimum());
	}

	/**
	* Gets the maximum accessible value of this object.
	*
	* @return the maximum value of this object
	*/
	public Number getMaximumAccessibleValue() {
	// TIGER - 4422362
	return Integer.valueOf(model.getMaximum() - model.getExtent());
	}

	} // AccessibleJProgressBar
	}

Back to index...