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.plaf.basic;

	import sun.swing.SwingUtilities2;
	import java.awt.*;
	import java.awt.geom.AffineTransform;
	import java.awt.event.*;
	import javax.swing.*;
	import javax.swing.event.*;
	import javax.swing.plaf.*;
	import java.beans.PropertyChangeListener;
	import java.beans.PropertyChangeEvent;
	import java.io.Serializable;
	import sun.swing.DefaultLookup;

	/**
	* A Basic L&F implementation of ProgressBarUI.
	*
	* @author Michael C. Albers
	* @author Kathy Walrath
	*/
	public class BasicProgressBarUI extends ProgressBarUI {
	private int cachedPercent;
	private int cellLength, cellSpacing;
	// The "selectionForeground" is the color of the text when it is painted
	// over a filled area of the progress bar. The "selectionBackground"
	// is for the text over the unfilled progress bar area.
	private Color selectionForeground, selectionBackground;

	private Animator animator;

	protected JProgressBar progressBar;
	protected ChangeListener changeListener;
	private Handler handler;

	/**
	* The current state of the indeterminate animation's cycle.
	* 0, the initial value, means paint the first frame.
	* When the progress bar is indeterminate and showing,
	* the default animation thread updates this variable
	* by invoking incrementAnimationIndex()
	* every repaintInterval milliseconds.
	*/
	private int animationIndex = 0;

	/**
	* The number of frames per cycle. Under the default implementation,
	* this depends on the cycleTime and repaintInterval. It
	* must be an even number for the default painting algorithm. This
	* value is set in the initIndeterminateValues method.
	*/
	private int numFrames; //0 1\|numFrames-1 ... numFrames/2

	/**
	* Interval (in ms) between repaints of the indeterminate progress bar.
	* The value of this method is set
	* (every time the progress bar changes to indeterminate mode)
	* using the
	* "ProgressBar.repaintInterval" key in the defaults table.
	*/
	private int repaintInterval;

	/**
	* The number of milliseconds until the animation cycle repeats.
	* The value of this method is set
	* (every time the progress bar changes to indeterminate mode)
	* using the
	* "ProgressBar.cycleTime" key in the defaults table.
	*/
	private int cycleTime; //must be repaintInterval2aPositiveInteger

	//performance stuff
	private static boolean ADJUSTTIMER = true; //makes a BIG difference;
	//make this false for
	//performance tests

	/**
	* Used to hold the location and size of the bouncing box (returned
	* by getBox) to be painted.
	*
	* @since 1.5
	*/
	protected Rectangle boxRect;

	/**
	* The rectangle to be updated the next time the
	* animation thread calls repaint. For bouncing-box
	* animation this rect should include the union of
	* the currently displayed box (which needs to be erased)
	* and the box to be displayed next.
	* This rectangle's values are set in
	* the setAnimationIndex method.
	*/
	private Rectangle nextPaintRect;

	//cache
	/** The component's painting area, not including the border. */
	private Rectangle componentInnards; //the current painting area
	private Rectangle oldComponentInnards; //used to see if the size changed

	/** For bouncing-box animation, the change in position per frame. */
	private double delta = 0.0;

	private int maxPosition = 0; //maximum X (horiz) or Y box location


	public static ComponentUI createUI(JComponent x) {
	return new BasicProgressBarUI();
	}

	public void installUI(JComponent c) {
	progressBar = (JProgressBar)c;
	installDefaults();
	installListeners();
	if (progressBar.isIndeterminate()) {
	initIndeterminateValues();
	}
	}

	public void uninstallUI(JComponent c) {
	if (progressBar.isIndeterminate()) {
	cleanUpIndeterminateValues();
	}
	uninstallDefaults();
	uninstallListeners();
	progressBar = null;
	}

	protected void installDefaults() {
	LookAndFeel.installProperty(progressBar, "opaque", Boolean.TRUE);
	LookAndFeel.installBorder(progressBar,"ProgressBar.border");
	LookAndFeel.installColorsAndFont(progressBar,
	"ProgressBar.background",
	"ProgressBar.foreground",
	"ProgressBar.font");
	cellLength = UIManager.getInt("ProgressBar.cellLength");
	if (cellLength == 0) cellLength = 1;
	cellSpacing = UIManager.getInt("ProgressBar.cellSpacing");
	selectionForeground = UIManager.getColor("ProgressBar.selectionForeground");
	selectionBackground = UIManager.getColor("ProgressBar.selectionBackground");
	}

	protected void uninstallDefaults() {
	LookAndFeel.uninstallBorder(progressBar);
	}

	protected void installListeners() {
	//Listen for changes in the progress bar's data.
	changeListener = getHandler();
	progressBar.addChangeListener(changeListener);

	//Listen for changes between determinate and indeterminate state.
	progressBar.addPropertyChangeListener(getHandler());
	}

	private Handler getHandler() {
	if (handler == null) {
	handler = new Handler();
	}
	return handler;
	}

	/**
	* Starts the animation thread, creating and initializing
	* it if necessary. This method is invoked when an
	* indeterminate progress bar should start animating.
	* Reasons for this may include:
	* <ul>
	* <li>The progress bar is determinate and becomes displayable
	* <li>The progress bar is displayable and becomes determinate
	* <li>The progress bar is displayable and determinate and this
	* UI is installed
	* </ul>
	* If you implement your own animation thread,
	* you must override this method.
	*
	* @since 1.4
	* @see #stopAnimationTimer
	*/
	protected void startAnimationTimer() {
	if (animator == null) {
	animator = new Animator();
	}

	animator.start(getRepaintInterval());
	}

	/**
	* Stops the animation thread.
	* This method is invoked when the indeterminate
	* animation should be stopped. Reasons for this may include:
	* <ul>
	* <li>The progress bar changes to determinate
	* <li>The progress bar is no longer part of a displayable hierarchy
	* <li>This UI in uninstalled
	* </ul>
	* If you implement your own animation thread,
	* you must override this method.
	*
	* @since 1.4
	* @see #startAnimationTimer
	*/
	protected void stopAnimationTimer() {
	if (animator != null) {
	animator.stop();
	}
	}

	/**
	* Removes all listeners installed by this object.
	*/
	protected void uninstallListeners() {
	progressBar.removeChangeListener(changeListener);
	progressBar.removePropertyChangeListener(getHandler());
	handler = null;
	}


	/**
	* Returns the baseline.
	*
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public int getBaseline(JComponent c, int width, int height) {
	super.getBaseline(c, width, height);
	if (progressBar.isStringPainted() &&
	progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	FontMetrics metrics = progressBar.
	getFontMetrics(progressBar.getFont());
	Insets insets = progressBar.getInsets();
	int y = insets.top;
	height = height - insets.top - insets.bottom;
	return y + (height + metrics.getAscent() -
	metrics.getLeading() -
	metrics.getDescent()) / 2;
	}
	return -1;
	}

	/**
	* Returns an enum indicating how the baseline of the component
	* changes as the size changes.
	*
	* @throws NullPointerException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public Component.BaselineResizeBehavior getBaselineResizeBehavior(
	JComponent c) {
	super.getBaselineResizeBehavior(c);
	if (progressBar.isStringPainted() &&
	progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	return Component.BaselineResizeBehavior.CENTER_OFFSET;
	}
	return Component.BaselineResizeBehavior.OTHER;
	}

	// Many of the Basic*UI components have the following methods.
	// This component does not have these methods because *ProgressBarUI
	// is not a compound component and does not accept input.
	//
	// protected void installComponents()
	// protected void uninstallComponents()
	// protected void installKeyboardActions()
	// protected void uninstallKeyboardActions()

	protected Dimension getPreferredInnerHorizontal() {
	Dimension horizDim = (Dimension)DefaultLookup.get(progressBar, this,
	"ProgressBar.horizontalSize");
	if (horizDim == null) {
	horizDim = new Dimension(146, 12);
	}
	return horizDim;
	}

	protected Dimension getPreferredInnerVertical() {
	Dimension vertDim = (Dimension)DefaultLookup.get(progressBar, this,
	"ProgressBar.verticalSize");
	if (vertDim == null) {
	vertDim = new Dimension(12, 146);
	}
	return vertDim;
	}

	/**
	* The "selectionForeground" is the color of the text when it is painted
	* over a filled area of the progress bar.
	*/
	protected Color getSelectionForeground() {
	return selectionForeground;
	}

	/**
	* The "selectionBackground" is the color of the text when it is painted
	* over an unfilled area of the progress bar.
	*/
	protected Color getSelectionBackground() {
	return selectionBackground;
	}

	private int getCachedPercent() {
	return cachedPercent;
	}

	private void setCachedPercent(int cachedPercent) {
	this.cachedPercent = cachedPercent;
	}

	/**
	* Returns the width (if HORIZONTAL) or height (if VERTICAL)
	* of each of the individual cells/units to be rendered in the
	* progress bar. However, for text rendering simplification and
	* aesthetic considerations, this function will return 1 when
	* the progress string is being rendered.
	*
	* @return the value representing the spacing between cells
	* @see #setCellLength
	* @see JProgressBar#isStringPainted
	*/
	protected int getCellLength() {
	if (progressBar.isStringPainted()) {
	return 1;
	} else {
	return cellLength;
	}
	}

	protected void setCellLength(int cellLen) {
	this.cellLength = cellLen;
	}

	/**
	* Returns the spacing between each of the cells/units in the
	* progress bar. However, for text rendering simplification and
	* aesthetic considerations, this function will return 0 when
	* the progress string is being rendered.
	*
	* @return the value representing the spacing between cells
	* @see #setCellSpacing
	* @see JProgressBar#isStringPainted
	*/
	protected int getCellSpacing() {
	if (progressBar.isStringPainted()) {
	return 0;
	} else {
	return cellSpacing;
	}
	}

	protected void setCellSpacing(int cellSpace) {
	this.cellSpacing = cellSpace;
	}

	/**
	* This determines the amount of the progress bar that should be filled
	* based on the percent done gathered from the model. This is a common
	* operation so it was abstracted out. It assumes that your progress bar
	* is linear. That is, if you are making a circular progress indicator,
	* you will want to override this method.
	*/
	protected int getAmountFull(Insets b, int width, int height) {
	int amountFull = 0;
	BoundedRangeModel model = progressBar.getModel();

	if ( (model.getMaximum() - model.getMinimum()) != 0) {
	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	amountFull = (int)Math.round(width *
	progressBar.getPercentComplete());
	} else {
	amountFull = (int)Math.round(height *
	progressBar.getPercentComplete());
	}
	}
	return amountFull;
	}

	/**
	* Delegates painting to one of two methods:
	* paintDeterminate or paintIndeterminate.
	*/
	public void paint(Graphics g, JComponent c) {
	if (progressBar.isIndeterminate()) {
	paintIndeterminate(g, c);
	} else {
	paintDeterminate(g, c);
	}
	}

	/**
	* Stores the position and size of
	* the bouncing box that would be painted for the current animation index
	* in <code>r</code> and returns <code>r</code>.
	* Subclasses that add to the painting performed
	* in this class's implementation of <code>paintIndeterminate</code> --
	* to draw an outline around the bouncing box, for example --
	* can use this method to get the location of the bouncing
	* box that was just painted.
	* By overriding this method,
	* you have complete control over the size and position
	* of the bouncing box,
	* without having to reimplement <code>paintIndeterminate</code>.
	*
	* @param r the Rectangle instance to be modified;
	* may be <code>null</code>
	* @return <code>null</code> if no box should be drawn;
	* otherwise, returns the passed-in rectangle
	* (if non-null)
	* or a new rectangle
	*
	* @see #setAnimationIndex
	* @since 1.4
	*/
	protected Rectangle getBox(Rectangle r) {
	int currentFrame = getAnimationIndex();
	int middleFrame = numFrames/2;

	if (sizeChanged() \|\| delta == 0.0 \|\| maxPosition == 0.0) {
	updateSizes();
	}

	r = getGenericBox(r);

	if (r == null) {
	return null;
	}
	if (middleFrame <= 0) {
	return null;
	}

	//assert currentFrame >= 0 && currentFrame < numFrames
	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	if (currentFrame < middleFrame) {
	r.x = componentInnards.x
	+ (int)Math.round(delta * (double)currentFrame);
	} else {
	r.x = maxPosition
	- (int)Math.round(delta *
	(currentFrame - middleFrame));
	}
	} else { //VERTICAL indeterminate progress bar
	if (currentFrame < middleFrame) {
	r.y = componentInnards.y
	+ (int)Math.round(delta * currentFrame);
	} else {
	r.y = maxPosition
	- (int)Math.round(delta *
	(currentFrame - middleFrame));
	}
	}
	return r;
	}

	/**
	* Updates delta, max position.
	* Assumes componentInnards is correct (e.g. call after sizeChanged()).
	*/
	private void updateSizes() {
	int length = 0;

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	length = getBoxLength(componentInnards.width,
	componentInnards.height);
	maxPosition = componentInnards.x + componentInnards.width
	- length;

	} else { //VERTICAL progress bar
	length = getBoxLength(componentInnards.height,
	componentInnards.width);
	maxPosition = componentInnards.y + componentInnards.height
	- length;
	}

	//If we're doing bouncing-box animation, update delta.
	delta = 2.0 * (double)maxPosition/(double)numFrames;
	}

	/**
	* Assumes that the component innards, max position, etc. are up-to-date.
	*/
	private Rectangle getGenericBox(Rectangle r) {
	if (r == null) {
	r = new Rectangle();
	}

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	r.width = getBoxLength(componentInnards.width,
	componentInnards.height);
	if (r.width < 0) {
	r = null;
	} else {
	r.height = componentInnards.height;
	r.y = componentInnards.y;
	}
	// end of HORIZONTAL

	} else { //VERTICAL progress bar
	r.height = getBoxLength(componentInnards.height,
	componentInnards.width);
	if (r.height < 0) {
	r = null;
	} else {
	r.width = componentInnards.width;
	r.x = componentInnards.x;
	}
	} // end of VERTICAL

	return r;
	}

	/**
	* Returns the length
	* of the "bouncing box" to be painted.
	* This method is invoked by the
	* default implementation of <code>paintIndeterminate</code>
	* to get the width (if the progress bar is horizontal)
	* or height (if vertical) of the box.
	* For example:
	* <blockquote>
	* <pre>
	*boxRect.width = getBoxLength(componentInnards.width,
	* componentInnards.height);
	* </pre>
	* </blockquote>
	*
	* @param availableLength the amount of space available
	* for the bouncing box to move in;
	* for a horizontal progress bar,
	* for example,
	* this should be
	* the inside width of the progress bar
	* (the component width minus borders)
	* @param otherDimension for a horizontal progress bar, this should be
	* the inside height of the progress bar; this
	* value might be used to constrain or determine
	* the return value
	*
	* @return the size of the box dimension being determined;
	* must be no larger than <code>availableLength</code>
	*
	* @see javax.swing.SwingUtilities#calculateInnerArea
	* @since 1.5
	*/
	protected int getBoxLength(int availableLength, int otherDimension) {
	return (int)Math.round(availableLength/6.0);
	}

	/**
	* All purpose paint method that should do the right thing for all
	* linear bouncing-box progress bars.
	* Override this if you are making another kind of
	* progress bar.
	*
	* @see #paintDeterminate
	*
	* @since 1.4
	*/
	protected void paintIndeterminate(Graphics g, JComponent c) {
	if (!(g instanceof Graphics2D)) {
	return;
	}

	Insets b = progressBar.getInsets(); // area for border
	int barRectWidth = progressBar.getWidth() - (b.right + b.left);
	int barRectHeight = progressBar.getHeight() - (b.top + b.bottom);

	if (barRectWidth <= 0 \|\| barRectHeight <= 0) {
	return;
	}

	Graphics2D g2 = (Graphics2D)g;

	// Paint the bouncing box.
	boxRect = getBox(boxRect);
	if (boxRect != null) {
	g2.setColor(progressBar.getForeground());
	g2.fillRect(boxRect.x, boxRect.y,
	boxRect.width, boxRect.height);
	}

	// Deal with possible text painting
	if (progressBar.isStringPainted()) {
	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	paintString(g2, b.left, b.top,
	barRectWidth, barRectHeight,
	boxRect.x, boxRect.width, b);
	}
	else {
	paintString(g2, b.left, b.top,
	barRectWidth, barRectHeight,
	boxRect.y, boxRect.height, b);
	}
	}
	}


	/**
	* All purpose paint method that should do the right thing for almost
	* all linear, determinate progress bars. By setting a few values in
	* the defaults
	* table, things should work just fine to paint your progress bar.
	* Naturally, override this if you are making a circular or
	* semi-circular progress bar.
	*
	* @see #paintIndeterminate
	*
	* @since 1.4
	*/
	protected void paintDeterminate(Graphics g, JComponent c) {
	if (!(g instanceof Graphics2D)) {
	return;
	}

	Insets b = progressBar.getInsets(); // area for border
	int barRectWidth = progressBar.getWidth() - (b.right + b.left);
	int barRectHeight = progressBar.getHeight() - (b.top + b.bottom);

	if (barRectWidth <= 0 \|\| barRectHeight <= 0) {
	return;
	}

	int cellLength = getCellLength();
	int cellSpacing = getCellSpacing();
	// amount of progress to draw
	int amountFull = getAmountFull(b, barRectWidth, barRectHeight);

	Graphics2D g2 = (Graphics2D)g;
	g2.setColor(progressBar.getForeground());

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	// draw the cells
	if (cellSpacing == 0 && amountFull > 0) {
	// draw one big Rect because there is no space between cells
	g2.setStroke(new BasicStroke((float)barRectHeight,
	BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
	} else {
	// draw each individual cell
	g2.setStroke(new BasicStroke((float)barRectHeight,
	BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL,
	0.f, new float[] { cellLength, cellSpacing }, 0.f));
	}

	if (BasicGraphicsUtils.isLeftToRight(c)) {
	g2.drawLine(b.left, (barRectHeight/2) + b.top,
	amountFull + b.left, (barRectHeight/2) + b.top);
	} else {
	g2.drawLine((barRectWidth + b.left),
	(barRectHeight/2) + b.top,
	barRectWidth + b.left - amountFull,
	(barRectHeight/2) + b.top);
	}

	} else { // VERTICAL
	// draw the cells
	if (cellSpacing == 0 && amountFull > 0) {
	// draw one big Rect because there is no space between cells
	g2.setStroke(new BasicStroke((float)barRectWidth,
	BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
	} else {
	// draw each individual cell
	g2.setStroke(new BasicStroke((float)barRectWidth,
	BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL,
	0f, new float[] { cellLength, cellSpacing }, 0f));
	}

	g2.drawLine(barRectWidth/2 + b.left,
	b.top + barRectHeight,
	barRectWidth/2 + b.left,
	b.top + barRectHeight - amountFull);
	}

	// Deal with possible text painting
	if (progressBar.isStringPainted()) {
	paintString(g, b.left, b.top,
	barRectWidth, barRectHeight,
	amountFull, b);
	}
	}


	protected void paintString(Graphics g, int x, int y,
	int width, int height,
	int amountFull, Insets b) {
	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	if (BasicGraphicsUtils.isLeftToRight(progressBar)) {
	if (progressBar.isIndeterminate()) {
	boxRect = getBox(boxRect);
	paintString(g, x, y, width, height,
	boxRect.x, boxRect.width, b);
	} else {
	paintString(g, x, y, width, height, x, amountFull, b);
	}
	}
	else {
	paintString(g, x, y, width, height, x + width - amountFull,
	amountFull, b);
	}
	}
	else {
	if (progressBar.isIndeterminate()) {
	boxRect = getBox(boxRect);
	paintString(g, x, y, width, height,
	boxRect.y, boxRect.height, b);
	} else {
	paintString(g, x, y, width, height, y + height - amountFull,
	amountFull, b);
	}
	}
	}

	/**
	* Paints the progress string.
	*
	* @param g Graphics used for drawing.
	* @param x x location of bounding box
	* @param y y location of bounding box
	* @param width width of bounding box
	* @param height height of bounding box
	* @param fillStart start location, in x or y depending on orientation,
	* of the filled portion of the progress bar.
	* @param amountFull size of the fill region, either width or height
	* depending upon orientation.
	* @param b Insets of the progress bar.
	*/
	private void paintString(Graphics g, int x, int y, int width, int height,
	int fillStart, int amountFull, Insets b) {
	if (!(g instanceof Graphics2D)) {
	return;
	}

	Graphics2D g2 = (Graphics2D)g;
	String progressString = progressBar.getString();
	g2.setFont(progressBar.getFont());
	Point renderLocation = getStringPlacement(g2, progressString,
	x, y, width, height);
	Rectangle oldClip = g2.getClipBounds();

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	g2.setColor(getSelectionBackground());
	SwingUtilities2.drawString(progressBar, g2, progressString,
	renderLocation.x, renderLocation.y);
	g2.setColor(getSelectionForeground());
	g2.clipRect(fillStart, y, amountFull, height);
	SwingUtilities2.drawString(progressBar, g2, progressString,
	renderLocation.x, renderLocation.y);
	} else { // VERTICAL
	g2.setColor(getSelectionBackground());
	AffineTransform rotate =
	AffineTransform.getRotateInstance(Math.PI/2);
	g2.setFont(progressBar.getFont().deriveFont(rotate));
	renderLocation = getStringPlacement(g2, progressString,
	x, y, width, height);
	SwingUtilities2.drawString(progressBar, g2, progressString,
	renderLocation.x, renderLocation.y);
	g2.setColor(getSelectionForeground());
	g2.clipRect(x, fillStart, width, amountFull);
	SwingUtilities2.drawString(progressBar, g2, progressString,
	renderLocation.x, renderLocation.y);
	}
	g2.setClip(oldClip);
	}


	/**
	* Designate the place where the progress string will be painted.
	* This implementation places it at the center of the progress
	* bar (in both x and y). Override this if you want to right,
	* left, top, or bottom align the progress string or if you need
	* to nudge it around for any reason.
	*/
	protected Point getStringPlacement(Graphics g, String progressString,
	int x,int y,int width,int height) {
	FontMetrics fontSizer = SwingUtilities2.getFontMetrics(progressBar, g,
	progressBar.getFont());
	int stringWidth = SwingUtilities2.stringWidth(progressBar, fontSizer,
	progressString);

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	return new Point(x + Math.round(width/2 - stringWidth/2),
	y + ((height +
	fontSizer.getAscent() -
	fontSizer.getLeading() -
	fontSizer.getDescent()) / 2));
	} else { // VERTICAL
	return new Point(x + ((width - fontSizer.getAscent() +
	fontSizer.getLeading() + fontSizer.getDescent()) / 2),
	y + Math.round(height/2 - stringWidth/2));
	}
	}


	public Dimension getPreferredSize(JComponent c) {
	Dimension size;
	Insets border = progressBar.getInsets();
	FontMetrics fontSizer = progressBar.getFontMetrics(
	progressBar.getFont());

	if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	size = new Dimension(getPreferredInnerHorizontal());
	// Ensure that the progress string will fit
	if (progressBar.isStringPainted()) {
	// I'm doing this for completeness.
	String progString = progressBar.getString();
	int stringWidth = SwingUtilities2.stringWidth(
	progressBar, fontSizer, progString);
	if (stringWidth > size.width) {
	size.width = stringWidth;
	}
	// This uses both Height and Descent to be sure that
	// there is more than enough room in the progress bar
	// for everything.
	// This does have a strange dependency on
	// getStringPlacememnt() in a funny way.
	int stringHeight = fontSizer.getHeight() +
	fontSizer.getDescent();
	if (stringHeight > size.height) {
	size.height = stringHeight;
	}
	}
	} else {
	size = new Dimension(getPreferredInnerVertical());
	// Ensure that the progress string will fit.
	if (progressBar.isStringPainted()) {
	String progString = progressBar.getString();
	int stringHeight = fontSizer.getHeight() +
	fontSizer.getDescent();
	if (stringHeight > size.width) {
	size.width = stringHeight;
	}
	// This is also for completeness.
	int stringWidth = SwingUtilities2.stringWidth(
	progressBar, fontSizer, progString);
	if (stringWidth > size.height) {
	size.height = stringWidth;
	}
	}
	}

	size.width += border.left + border.right;
	size.height += border.top + border.bottom;
	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;
	}

	/**
	* Returns the number of frames for the complete animation loop
	* used by an indeterminate JProgessBar. The progress chunk will go
	* from one end to the other and back during the entire loop. This
	* visual behavior may be changed by subclasses in other Look and Feels.
	*
	* @return the number of frames
	* @since 1.6
	*/
	protected final int getFrameCount() {
	return numFrames;
	}

	/**
	* 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 = repaintIntervalfactor2;
	}
	}

	/**
	* 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 class should be treated as a "protected" inner class.
	* Instantiate it only within subclasses of {@code BasicProgressBarUI}.
	*/
	public class ChangeHandler implements ChangeListener {
	// NOTE: This class exists only for backward compatibility. 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();
	}
	}
	}
	}
	}
	}

Back to index...