Back to index...

	/*
	* Copyright (c) 1997, 2014, 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 com.sun.java.swing.plaf.windows;

	import javax.swing.plaf.basic.*;
	import javax.swing.plaf.*;
	import javax.swing.*;
	import java.awt.*;

	import static com.sun.java.swing.plaf.windows.TMSchema.*;
	import static com.sun.java.swing.plaf.windows.XPStyle.Skin;


	/**
	* Windows rendition of the component.
	* <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. A future release of Swing will provide support for
	* long term persistence.
	*
	* @author Michael C. Albers
	*/
	public class WindowsProgressBarUI extends BasicProgressBarUI
	{

	private Rectangle previousFullBox;
	private Insets indeterminateInsets;

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


	protected void installDefaults() {
	super.installDefaults();

	if (XPStyle.getXP() != null) {
	LookAndFeel.installProperty(progressBar, "opaque", Boolean.FALSE);
	progressBar.setBorder(null);
	indeterminateInsets = UIManager.getInsets("ProgressBar.indeterminateInsets");
	}
	}

	/**
	* 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) {
	int baseline = super.getBaseline(c, width, height);
	if (XPStyle.getXP() != null && progressBar.isStringPainted() &&
	progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
	FontMetrics metrics = progressBar.
	getFontMetrics(progressBar.getFont());
	int y = progressBar.getInsets().top;
	if (progressBar.isIndeterminate()) {
	y = -1;
	height--;
	}
	else {
	y = 0;
	height -= 3;
	}
	baseline = y + (height + metrics.getAscent() -
	metrics.getLeading() -
	metrics.getDescent()) / 2;
	}
	return baseline;
	}

	protected Dimension getPreferredInnerHorizontal() {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	Skin skin = xp.getSkin(progressBar, Part.PP_BAR);
	return new Dimension(
	(int)super.getPreferredInnerHorizontal().getWidth(),
	skin.getHeight());
	}
	return super.getPreferredInnerHorizontal();
	}

	protected Dimension getPreferredInnerVertical() {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	Skin skin = xp.getSkin(progressBar, Part.PP_BARVERT);
	return new Dimension(
	skin.getWidth(),
	(int)super.getPreferredInnerVertical().getHeight());
	}
	return super.getPreferredInnerVertical();
	}

	protected void paintDeterminate(Graphics g, JComponent c) {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	boolean vertical = (progressBar.getOrientation() == JProgressBar.VERTICAL);
	boolean isLeftToRight = WindowsGraphicsUtils.isLeftToRight(c);
	int barRectWidth = progressBar.getWidth();
	int barRectHeight = progressBar.getHeight()-1;
	// amount of progress to draw
	int amountFull = getAmountFull(null, barRectWidth, barRectHeight);

	paintXPBackground(g, vertical, barRectWidth, barRectHeight);
	// Paint progress
	if (progressBar.isStringPainted()) {
	// Do not paint the standard stripes from the skin, because they obscure
	// the text
	g.setColor(progressBar.getForeground());
	barRectHeight -= 2;
	barRectWidth -= 2;

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

	Graphics2D g2 = (Graphics2D)g;
	g2.setStroke(new BasicStroke((float)(vertical ? barRectWidth : barRectHeight),
	BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
	if (!vertical) {
	if (isLeftToRight) {
	g2.drawLine(2, barRectHeight / 2 + 1,
	amountFull - 2, barRectHeight / 2 + 1);
	} else {
	g2.drawLine(2 + barRectWidth,
	barRectHeight / 2 + 1,
	2 + barRectWidth - (amountFull - 2),
	barRectHeight / 2 + 1);
	}
	paintString(g, 0, 0, barRectWidth, barRectHeight, amountFull, null);
	} else {
	g2.drawLine(barRectWidth/2 + 1, barRectHeight + 1,
	barRectWidth/2 + 1, barRectHeight + 1 - amountFull + 2);
	paintString(g, 2, 2, barRectWidth, barRectHeight, amountFull, null);
	}

	} else {
	Skin skin = xp.getSkin(progressBar, vertical ? Part.PP_CHUNKVERT : Part.PP_CHUNK);
	int thickness;
	if (vertical) {
	thickness = barRectWidth - 5;
	} else {
	thickness = barRectHeight - 5;
	}

	int chunkSize = xp.getInt(progressBar, Part.PP_PROGRESS, null, Prop.PROGRESSCHUNKSIZE, 2);
	int spaceSize = xp.getInt(progressBar, Part.PP_PROGRESS, null, Prop.PROGRESSSPACESIZE, 0);
	int nChunks = (amountFull-4) / (chunkSize + spaceSize);

	// See if we can squeeze in an extra chunk without spacing after
	if (spaceSize > 0 && (nChunks * (chunkSize + spaceSize) + chunkSize) < (amountFull-4)) {
	nChunks++;
	}

	for (int i = 0; i < nChunks; i++) {
	if (vertical) {
	skin.paintSkin(g,
	3, barRectHeight - i * (chunkSize + spaceSize) - chunkSize - 2,
	thickness, chunkSize, null);
	} else {
	if (isLeftToRight) {
	skin.paintSkin(g,
	4 + i * (chunkSize + spaceSize), 2,
	chunkSize, thickness, null);
	} else {
	skin.paintSkin(g,
	barRectWidth - (2 + (i+1) * (chunkSize + spaceSize)), 2,
	chunkSize, thickness, null);
	}
	}
	}
	}
	} else {
	super.paintDeterminate(g, c);
	}
	}


	/**
	* {@inheritDoc}
	* @since 1.6
	*/
	protected void setAnimationIndex(int newValue) {
	super.setAnimationIndex(newValue);
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	if (boxRect != null) {
	// get the full repaint area and add it the
	// previous one so we can erase it
	Rectangle chunk = getFullChunkBounds(boxRect);
	if (previousFullBox != null) {
	chunk.add(previousFullBox);
	}
	progressBar.repaint(chunk);
	} else {
	progressBar.repaint();
	}
	}
	}


	/**
	* {@inheritDoc}
	* @since 1.6
	*/
	protected int getBoxLength(int availableLength, int otherDimension) {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	return 6; // an apparently hard coded value in Windows
	}
	return super.getBoxLength(availableLength, otherDimension);
	}

	/**
	* {@inheritDoc}
	* @since 1.6
	*/
	protected Rectangle getBox(Rectangle r) {
	Rectangle rect = super.getBox(r);

	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	boolean vertical = (progressBar.getOrientation()
	== JProgressBar.VERTICAL);
	Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
	Insets ins = indeterminateInsets;

	int currentFrame = getAnimationIndex();
	int framecount = getFrameCount()/2;

	int gap = xp.getInt(progressBar, Part.PP_PROGRESS, null,
	Prop.PROGRESSSPACESIZE, 0);
	currentFrame = currentFrame % framecount;

	// this code adjusts the chunk size to properly account for the
	// size and gap specified in the XP style. It also does it's own
	// box placement for the chunk animation. This is required because
	// the inherited algorithm from BasicProgressBarUI goes back and
	// forth whereas XP only goes in one direction. XP also has ghosted
	// trailing chunks to create the illusion of speed. This code
	// adjusts the pixel length of the animation to account for the
	// trails.
	if (!vertical) {
	rect.y = rect.y + ins.top;
	rect.height = progressBar.getHeight() - ins.top - ins.bottom;
	int len = progressBar.getWidth() - ins.left - ins.right;
	len += (rect.width+gap)*2; // add 2x for the trails
	double delta = (double)(len) / (double)framecount;
	rect.x = (int)(delta * currentFrame) + ins.left;
	} else {
	rect.x = rect.x + ins.left;
	rect.width = progressBar.getWidth() - ins.left - ins.right;
	int len = progressBar.getHeight() - ins.top - ins.bottom;
	len += (rect.height+gap)*2; // add 2x for the trails
	double delta = (double)(len) / (double)framecount;
	rect.y = (int)(delta * currentFrame) + ins.top;
	}
	}
	return rect;
	}


	protected void paintIndeterminate(Graphics g, JComponent c) {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	boolean vertical = (progressBar.getOrientation()
	== JProgressBar.VERTICAL);
	int barRectWidth = progressBar.getWidth();
	int barRectHeight = progressBar.getHeight();
	paintXPBackground(g, vertical, barRectWidth, barRectHeight);

	// Paint the bouncing box.
	boxRect = getBox(boxRect);
	if (boxRect != null) {
	g.setColor(progressBar.getForeground());
	if (!(g instanceof Graphics2D)) {
	return;
	}
	paintIndeterminateFrame(boxRect, (Graphics2D)g, vertical,
	barRectWidth, barRectHeight);
	if (progressBar.isStringPainted()) {
	if (!vertical) {
	paintString(g, -1, -1, barRectWidth, barRectHeight, 0, null);
	} else {
	paintString(g, 1, 1, barRectWidth, barRectHeight, 0, null);
	}
	}
	}
	} else {
	super.paintIndeterminate(g, c);
	}
	}

	private Rectangle getFullChunkBounds(Rectangle box) {
	boolean vertical = (progressBar.getOrientation() == JProgressBar.VERTICAL);
	XPStyle xp = XPStyle.getXP();
	int gap = (xp != null) ? xp.getInt(progressBar, Part.PP_PROGRESS,
	null, Prop.PROGRESSSPACESIZE, 0)
	: 0;

	if (!vertical) {
	int chunksize = box.width+gap;
	return new Rectangle(box.x-chunksize2, box.y, chunksize3, box.height);
	} else {
	int chunksize = box.height+gap;
	return new Rectangle(box.x, box.y-chunksize2, box.width, chunksize3);
	}
	}

	private void paintIndeterminateFrame(Rectangle box, Graphics2D g,
	boolean vertical,
	int bgwidth, int bgheight) {
	XPStyle xp = XPStyle.getXP();
	if (xp == null) {
	return;
	}

	// create a new graphics to keep drawing surface state
	Graphics2D gfx = (Graphics2D)g.create();

	Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
	Part chunk = vertical ? Part.PP_CHUNKVERT : Part.PP_CHUNK;

	// calculate the chunk offsets
	int gap = xp.getInt(progressBar, Part.PP_PROGRESS, null,
	Prop.PROGRESSSPACESIZE, 0);
	int deltax = 0;
	int deltay = 0;
	if (!vertical) {
	deltax = -box.width - gap;
	deltay = 0;
	} else {
	deltax = 0;
	deltay = -box.height - gap;
	}

	// Calculate the area of the chunks combined
	Rectangle fullBox = getFullChunkBounds(box);

	// save this box for the next time
	previousFullBox = fullBox;

	// this is the entire progress bar minus the track and borders
	Insets ins = indeterminateInsets;
	Rectangle progbarExtents = new Rectangle(ins.left, ins.top,
	bgwidth - ins.left - ins.right,
	bgheight - ins.top - ins.bottom);

	// only paint where the chunks overlap with the progress bar drawing area
	Rectangle repaintArea = progbarExtents.intersection(fullBox);

	// adjust the cliprect to chop the chunks when they go off the end
	gfx.clip(repaintArea);

	// get the skin
	XPStyle.Skin skin = xp.getSkin(progressBar, chunk);

	// do the drawing
	gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f));
	skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);
	box.translate(deltax, deltay);
	gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
	skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);
	box.translate(deltax, deltay);
	gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
	skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);

	// get rid of our clip and composite changes
	gfx.dispose();
	}

	private void paintXPBackground(Graphics g, boolean vertical,
	int barRectWidth, int barRectHeight) {
	XPStyle xp = XPStyle.getXP();
	if (xp == null) {
	return;
	}
	Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
	Skin skin = xp.getSkin(progressBar, part);

	// Paint background
	skin.paintSkin(g, 0, 0, barRectWidth, barRectHeight, null);
	}
	}

Back to index...