return size;    }    /**     * The Minimum size for this component is 10. The rationale here      * is that there should be at least one pixel per 10 percent.     */    public Dimension getMinimumSize(JComponent c) {	Dimension pref = getPreferredSize(progressBar);	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {	    pref.width = 10;	} else {	    pref.height = 10;	}	return pref;    }    public Dimension getMaximumSize(JComponent c) {	Dimension pref = getPreferredSize(progressBar);	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {	    pref.width = Short.MAX_VALUE;	} else {	    pref.height = Short.MAX_VALUE;	}	return pref;    }    /**     * Gets the index of the current animation frame.     *     * @since 1.4     */    protected int getAnimationIndex() {	return animationIndex;    }    /**     * 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 <code>repaint</code> method     * is invoked.     *     * @param newValue the new animation index; no checking     *                 is performed on its value     * @see #incrementAnimationIndex     *     * @since 1.4     */    protected void setAnimationIndex(int newValue) {        if (animationIndex != newValue) {            if (sizeChanged()) {                 animationIndex = newValue;                maxPosition = 0;  //needs to be recalculated                delta = 0.0;      //needs to be recalculated                progressBar.repaint();                return;            }            //Get the previous box drawn.            nextPaintRect = getBox(nextPaintRect);            //Update the frame number.            animationIndex = newValue;                            //Get the next box to draw.            if (nextPaintRect != null) {                boxRect = getBox(boxRect);                if (boxRect != null) {                    nextPaintRect.add(boxRect);                }            }        } else { //animationIndex == newValue            return;        }        if (nextPaintRect != null) {            progressBar.repaint(nextPaintRect);        } else {            progressBar.repaint();        }    }    private boolean sizeChanged() {        if ((oldComponentInnards == null) || (componentInnards == null)) {	    return true;	}        oldComponentInnards.setRect(componentInnards);        componentInnards = SwingUtilities.calculateInnerArea(progressBar,	                                                     componentInnards);        return !oldComponentInnards.equals(componentInnards);    }    /**     * 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 <em>X</em> milliseconds,      * where <em>X</em> is specified by the "ProgressBar.repaintInterval"     * UI default.     *     * @see #setAnimationIndex     * @since 1.4     */    protected void incrementAnimationIndex() {        int newValue = getAnimationIndex() + 1;        if (newValue < numFrames) {            setAnimationIndex(newValue);        } else {            setAnimationIndex(0);        }    }    /**     * Returns the desired number of milliseconds between repaints.     * This value is meaningful     * only if the progress bar is in indeterminate mode.     * The repaint interval determines how often the      * default animation thread's timer is fired.     * It's also used by the default indeterminate progress bar     * painting code when determining     * how far to move the bouncing box per frame.     * The repaint interval is specified by     * the "ProgressBar.repaintInterval" UI default.     *      * @return  the repaint interval, in milliseconds     */    private int getRepaintInterval() {        return repaintInterval;    }    private int initRepaintInterval() {        repaintInterval = DefaultLookup.getInt(progressBar,                this, "ProgressBar.repaintInterval", 50);        return repaintInterval;    }    /**     * Returns the number of milliseconds per animation cycle.     * This value is meaningful     * only if the progress bar is in indeterminate mode.     * The cycle time is used by the default indeterminate progress bar     * painting code when determining     * how far to move the bouncing box per frame.     * The cycle time is specified by     * the "ProgressBar.cycleTime" UI default     * and adjusted, if necessary,     * by the initIndeterminateDefaults method.     *      * @return  the cycle time, in milliseconds     */    private int getCycleTime() {        return cycleTime;    }    private int initCycleTime() {        cycleTime = DefaultLookup.getInt(progressBar, this,                "ProgressBar.cycleTime", 3000);        return cycleTime;    }    /** Initialize cycleTime, repaintInterval, numFrames, animationIndex. */    private void initIndeterminateDefaults() {        initRepaintInterval(); //initialize repaint interval        initCycleTime();       //initialize cycle length        // Make sure repaintInterval is reasonable.        if (repaintInterval <= 0) {            repaintInterval = 100;        }        // Make sure cycleTime is reasonable.        if (repaintInterval > cycleTime) {            cycleTime = repaintInterval * 20;        } else {            // Force cycleTime to be a even multiple of repaintInterval.            int factor = (int)Math.ceil(                                 ((double)cycleTime)                               / ((double)repaintInterval*2));            cycleTime = repaintInterval*factor*2;        }    }    /**     * Invoked by PropertyChangeHandler.     *     *  NOTE: This might not be invoked until after the first     *  paintIndeterminate call.     */    private void initIndeterminateValues() {        initIndeterminateDefaults();        //assert cycleTime/repaintInterval is a whole multiple of 2.        numFrames = cycleTime/repaintInterval;        initAnimationIndex();                    boxRect = new Rectangle();        nextPaintRect = new Rectangle();        componentInnards = new Rectangle();        oldComponentInnards = new Rectangle();        // we only bother installing the HierarchyChangeListener if we        // are indeterminate        progressBar.addHierarchyListener(getHandler());        // start the animation thread if necessary        if (progressBar.isDisplayable()) {            startAnimationTimer();        }    }    /** Invoked by PropertyChangeHandler. */    private void cleanUpIndeterminateValues() {        // stop the animation thread if necessary        if (progressBar.isDisplayable()) {            stopAnimationTimer();        }        cycleTime = repaintInterval = 0;        numFrames = animationIndex = 0;        maxPosition = 0;        delta = 0.0;        boxRect = nextPaintRect = null;        componentInnards = oldComponentInnards = null;        progressBar.removeHierarchyListener(getHandler());    }    // Called from initIndeterminateValues to initialize the animation index.    // This assumes that numFrames is set to a correct value.    private void initAnimationIndex() {        if ((progressBar.getOrientation() == JProgressBar.HORIZONTAL) &&            (BasicGraphicsUtils.isLeftToRight(progressBar))) {            // If this is a left-to-right progress bar,	    // start at the first frame.            setAnimationIndex(0);        } else {            // If we go right-to-left or vertically, start at the right/bottom.            setAnimationIndex(numFrames/2);        }    }    //    // Animation Thread    //    /**     * Implements an animation thread that invokes repaint     * at a fixed rate.  If ADJUSTTIMER is true, this thread     * will continuously adjust the repaint interval to      * try to make the actual time between repaints match     * the requested rate.       */    private class Animator implements ActionListener {        private Timer timer;        private long previousDelay; //used to tune the repaint interval        private int interval; //the fixed repaint interval        private long lastCall; //the last time actionPerformed was called        private int MINIMUM_DELAY = 5;	/**	 * Creates a timer if one doesn't already exist, 	 * then starts the timer thread.	 */        private void start(int interval) {            previousDelay = interval;            lastCall = 0;	    if (timer == null) {                timer = new Timer(interval, this);	    } else {                timer.setDelay(interval);	    }	    if (ADJUSTTIMER) {		timer.setRepeats(false);                timer.setCoalesce(false);	    }	    timer.start();	}	/**	 * Stops the timer thread.	 */	private void stop() {	    timer.stop();	}	/**	 * Reacts to the timer's action events.	 */	public void actionPerformed(ActionEvent e) {            if (ADJUSTTIMER) {                long time = System.currentTimeMillis();                if (lastCall > 0) { //adjust nextDelay                //XXX maybe should cache this after a while                    //actual = time - lastCall                    //difference = actual - interval                    //nextDelay = previousDelay - difference                    //          = previousDelay - (time - lastCall - interval)                   int nextDelay = (int)(previousDelay                                          - time + lastCall                                          + getRepaintInterval());                    if (nextDelay < MINIMUM_DELAY) {                        nextDelay = MINIMUM_DELAY;                    }                    timer.setInitialDelay(nextDelay);                    previousDelay = nextDelay;                }                timer.start();                lastCall = time;            }	    incrementAnimationIndex(); //paint next frame	}    }    /**     * This inner class is marked &quot;public&quot; due to a compiler bug.     * This class should be treated as a &quot;protected&quot; inner class.     * Instantiate it only within subclasses of BasicProgressBarUI.     */    public class ChangeHandler implements ChangeListener {        // NOTE: This class exists only for backward compatability. All        // its functionality has been moved into Handler. If you need to add        // new functionality add it to the Handler, but make sure this              // class calls into the Handler.	public void stateChanged(ChangeEvent e) {            getHandler().stateChanged(e);	}    }    private class Handler implements ChangeListener, PropertyChangeListener, HierarchyListener {        // ChangeListener	public void stateChanged(ChangeEvent e) {	    BoundedRangeModel model = progressBar.getModel();	    int newRange = model.getMaximum() - model.getMinimum();	    int newPercent;	    int oldPercent = getCachedPercent();	    	    if (newRange > 0) {		newPercent = (int)((100 * (long)model.getValue()) / newRange);	    } else {		newPercent = 0;	    }	    	    if (newPercent != oldPercent) {		setCachedPercent(newPercent);		progressBar.repaint();	    }	}        // PropertyChangeListener	public void propertyChange(PropertyChangeEvent e) {	    String prop = e.getPropertyName();	    if ("indeterminate" == prop) {		if (progressBar.isIndeterminate()) {                    initIndeterminateValues();	        } else {                    //clean up                    cleanUpIndeterminateValues();                }                progressBar.repaint();            }        }                // we don't want the animation to keep running if we're not displayable        public void hierarchyChanged(HierarchyEvent he) {            if ((he.getChangeFlags() & HierarchyEvent.DISPLAYABILITY_CHANGED) != 0) {                if (progressBar.isIndeterminate()) {                    if (progressBar.isDisplayable()) {                        startAnimationTimer();                    } else {                        stopAnimationTimer();                    }                }            }        }    }}