/* * Copyright (c) 1997, 2008, 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. *

* {@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. *

* 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. * *

* * Here is an example of creating a progress bar, * where task is an object (representing some piece of work) * which returns information about the progress of the task: * *

 *progressBar = new JProgressBar(0, task.getLengthOfTask());
 *progressBar.setValue(0);
 *progressBar.setStringPainted(true);
 *
* * Here is an example of querying the current state of the task, and using * the returned value to update the progress bar: * *
 *progressBar.setValue(task.getCurrent());
 *
* * 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: * *
 *progressBar = new JProgressBar();
 *...//when the task of (initially) unknown length begins:
 *progressBar.setIndeterminate(true);
 *...//do some work; get length of task...
 *progressBar.setMaximum(newLength);
 *progressBar.setValue(newValue);
 *progressBar.setIndeterminate(false);
 *
* *

* * For complete examples and further documentation see * How to Monitor Progress, * a section in The Java Tutorial. * *

* Warning: Swing is not thread safe. For more * information see Swing's Threading * Policy. *

* Warning: * 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 JavaBeansTM * has been added to the java.beans 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 HORIZONTAL. * * @see #setOrientation */ protected int orientation; /** * Whether to display a border around the progress bar. * The default is true. * * @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 null. Setting this to a non-null * 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 false. * Setting this to true causes a textual * display of the progress to be rendered on the progress bar. If * the progressString is null, * the percentage of completion is displayed on the progress bar. * Otherwise, the progressString 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 HORIZONTAL. */ static final private int defaultOrientation = HORIZONTAL; /** * Only one ChangeEvent 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 (true) or * normal (false); the default is false. * * @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. *

* The BoundedRangeModel 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. *

* The BoundedRangeModel 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 HORIZONTAL or VERTICAL * @see #setOrientation */ public int getOrientation() { return orientation; } /** * Sets the progress bar's orientation to newOrientation, * which must be {@code SwingConstants.VERTICAL} or * {@code SwingConstants.HORIZONTAL}. The default orientation * is {@code SwingConstants.HORIZONTAL}. * * @param newOrientation HORIZONTAL or VERTICAL * @exception IllegalArgumentException if newOrientation * 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 stringPainted property. * * @return the value of the stringPainted property * @see #setStringPainted * @see #setString */ public boolean isStringPainted() { return paintString; } /** * Sets the value of the stringPainted property, * which determines whether the progress bar * should render a progress string. * The default is false, 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 true 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 null, 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 null. *

* The progress string is painted only if * the isStringPainted method returns true. * * @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 borderPainted property. * * @return the value of the borderPainted property * @see #setBorderPainted * @beaninfo * description: Does the progress bar paint its border */ public boolean isBorderPainted() { return paintBorder; } /** * Sets the borderPainted property, which is * true if the progress bar should paint its border. * The default value for this property is true. * Some look and feels might not implement painted borders; * they will ignore this property. * * @param b true if the progress bar * should paint its border; * otherwise, false * @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 borderPainted * property is true. * * @param g the Graphics 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 ProgressBarUI object that renders this component */ public ProgressBarUI getUI() { return (ProgressBarUI)ui; } /** * Sets the look-and-feel object that renders this component. * * @param ui a ProgressBarUI 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. *

* Warning: * 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 JavaBeansTM * has been added to the java.beans 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 ChangeListener 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 ChangeListener to the progress bar. * * @param l the ChangeListener to add */ public void addChangeListener(ChangeListener l) { listenerList.add(ChangeListener.class, l); } /** * Removes a ChangeListener from the progress bar. * * @param l the ChangeListener to remove */ public void removeChangeListener(ChangeListener l) { listenerList.remove(ChangeListener.class, l); } /** * Returns an array of all the ChangeListeners added * to this progress bar with addChangeListener. * * @return all of the ChangeListeners 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. *

* * 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 BoundedRangeModel currently in use * @see #setModel * @see BoundedRangeModel */ public BoundedRangeModel getModel() { return model; } /** * Sets the data model used by the JProgressBar. * Note that the {@code BoundedRangeModel}'s {@code extent} is not used, * and is set to {@code 0}. * * @param newModel the BoundedRangeModel 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 BoundedRangeModel. * 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 BoundedRangeModel. * * @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 BoundedRangeModel. * * @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. *

* The data model (an instance of {@code BoundedRangeModel}) * handles any mathematical * issues arising from assigning faulty values. See the * {@code BoundedRangeModel} documentation for details. *

* 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 n. *

* The data model (a BoundedRangeModel instance) * handles any mathematical * issues arising from assigning faulty values. * See the {@code BoundedRangeModel} documentation for details. *

* 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 n. *

* The underlying BoundedRangeModel handles any mathematical * issues arising from assigning faulty values. * See the {@code BoundedRangeModel} documentation for details. *

* 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 indeterminate 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 false. * Some look and feels might not support indeterminate progress bars; * they will ignore this property. * *

* * See * How to Monitor Progress * for examples of using indeterminate progress bars. * * @param newValue true if the progress bar * should change to indeterminate mode; * false 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 indeterminate property. * * @return the value of the indeterminate 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 JProgressBar. * 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 null. * * @return a string representation of this JProgressBar */ 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 AccessibleContext associated with this * JProgressBar. For progress bars, the * AccessibleContext takes the form of an * AccessibleJProgressBar. * A new AccessibleJProgressBar instance is created if necessary. * * @return an AccessibleJProgressBar that serves as the * AccessibleContext of this JProgressBar * @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 * JProgressBar class. It provides an implementation of the * Java Accessibility API appropriate to progress bar user-interface * elements. *

* Warning: * 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 JavaBeansTM * has been added to the java.beans 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 AccessibleValue associated with this object. In the * implementation of the Java Accessibility API for this class, * returns this object, which is responsible for implementing the * AccessibleValue 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 Number. * * @return true 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 }