/**
*
* JFreeReport : a free Java reporting library
*
*
* Project Info: http://reporting.pentaho.org/
*
* (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
*
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation;
* either version 2.1 of the License, or (at your option) any later version.
*
* This library 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* ------------
* StrokeUtility.java
* ------------
* (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
*/
import java.awt.BasicStroke;
import java.awt.Stroke;
import java.util.Arrays;
/**
* This class provides helper methods to work with Strokes and line-styles.
*
* @author Thomas Morgner
*/
public class StrokeUtility {
/** A constant defining a stroke-type. */
public static final int STROKE_SOLID = 0;
/** A constant defining a stroke-type. */
public static final int STROKE_DASHED = 1;
/** A constant defining a stroke-type. */
public static final int STROKE_DOTTED = 2;
/** A constant defining a stroke-type. */
public static final int STROKE_DOT_DASH = 3;
/** A constant defining a stroke-type. */
public static final int STROKE_DOT_DOT_DASH = 4;
/** A constant defining a stroke-type. */
public static final int STROKE_NONE = 5;
/**
* Default Constructor. Private to prevent Object-creation.
*/
private StrokeUtility() {
}
/**
* Creates a new Stroke-Object for the given type and with.
*
* @param type
* the stroke-type. (Must be one of the constants defined in this
* class.)
* @param width
* the stroke's width.
* @return the stroke, never null.
*/
public static Stroke createStroke(final int type, final float width) {
final boolean useWidthForStrokes = true;
final float effectiveWidth;
if (useWidthForStrokes) {
effectiveWidth = width;
} else {
effectiveWidth = 1;
}
switch (type) {
case STROKE_DASHED:
return new BasicStroke(width, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10.0f,
new float[] { 6 * effectiveWidth, 6 * effectiveWidth }, 0.0f);
case STROKE_DOTTED:
return new BasicStroke(width, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 5.0f,
new float[] { 0.0f, 2 * effectiveWidth }, 0.0f);
case STROKE_DOT_DASH:
return new BasicStroke(width, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10.0f,
new float[] { 0, 2 * effectiveWidth, 6 * effectiveWidth, 2 * effectiveWidth }, 0.0f);
case STROKE_DOT_DOT_DASH:
return new BasicStroke(width, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10.0f,
new float[] { 0, 2 * effectiveWidth, 0, 2 * effectiveWidth, 6 * effectiveWidth,
2 * effectiveWidth }, 0.0f);
default:
return new BasicStroke(width);
}
}
/**
* Tries to extract the stroke-width from the given stroke object.
*
* @param s
* the stroke.
* @return the stroke's width.
*/
public static float getStrokeWidth(final Stroke s) {
if (s instanceof BasicStroke) {
final BasicStroke bs = (BasicStroke) s;
return bs.getLineWidth();
}
return 1;
}
/**
* Tries to deduct the stroke-type from the given stroke object. This will
* result in funny return values if the stroke was not created by the
* {@link #createStroke(int, float)} method.
*
* @param s
* the stroke.
* @return the stroke's width.
*/
public static int getStrokeType(final Stroke s) {
if (s instanceof BasicStroke == false) {
return STROKE_SOLID;
}
final BasicStroke bs = (BasicStroke) s;
if (bs.getLineWidth() <= 0) {
return STROKE_NONE;
}
final float[] dashes = bs.getDashArray();
if (dashes == null) {
return STROKE_SOLID;
}
if (dashes.length < 2) {
return STROKE_SOLID;
}
if (dashes.length == 3 || dashes.length == 5) {
return STROKE_SOLID;
}
if (dashes.length == 2) {
// maybe dashed or dotted ...
// if (dashes[0] < 2 && dashes[1] < 2) {
// return STROKE_DOTTED;
// }
final float factor = dashes[0] / dashes[1];
if (factor > 0.9 && factor < 1.1) {
return STROKE_DASHED;
} else if (factor < 0.1) {
return STROKE_DOTTED;
}
// else ... not recognized ...
return STROKE_SOLID;
} else if (dashes.length == 4) {
// maybe a dot-dashed stroke ...
final float[] copyDashes = (float[]) dashes.clone();
Arrays.sort(copyDashes);
// the first value should be near zero ..
if (Math.abs(copyDashes[0] / bs.getLineWidth()) > 0.5) {
// not recognized ..
return STROKE_SOLID;
}
// test that the first two values have the same size
final float factor1 = (2 * bs.getLineWidth()) / copyDashes[1];
final float factor2 = (2 * bs.getLineWidth()) / copyDashes[2];
final float factorBig = (2 * bs.getLineWidth()) / copyDashes[3];
if ((factor1 < 0.9 || factor1 > 1.1) || (factor2 < 0.9 || factor2 > 1.1)) {
// not recognized ...
return STROKE_SOLID;
}
if (factorBig < 0.4 || factorBig > 2.5) {
return STROKE_DOT_DASH;
}
if (factorBig < 0.9 || factorBig > 1.1) {
return STROKE_DOTTED;
}
return STROKE_DASHED;
} else if (dashes.length == 6) {
// maybe a dot-dashed stroke ...
final float[] copyDashes = (float[]) dashes.clone();
Arrays.sort(copyDashes);
// test that the first three values have the same size
// the first two values should be near zero ..
if (Math.abs(copyDashes[0] / bs.getLineWidth()) > 0.5) {
// not recognized ..
return STROKE_SOLID;
}
if (Math.abs(copyDashes[1] / bs.getLineWidth()) > 0.5) {
// not recognized ..
return STROKE_SOLID;
}
final float factor2 = (2 * bs.getLineWidth()) / copyDashes[2];
final float factor3 = (2 * bs.getLineWidth()) / copyDashes[3];
final float factor4 = (2 * bs.getLineWidth()) / copyDashes[4];
final float factorBig = (2 * bs.getLineWidth()) / copyDashes[5];
if ((factor2 < 0.9 || factor2 > 1.1) || (factor3 < 0.9 || factor3 > 1.1)
|| (factor4 < 0.9 || factor4 > 1.1)) {
return STROKE_SOLID;
}
if (factorBig < 0.4 || factorBig > 2.5) {
return STROKE_DOT_DOT_DASH;
}
if ((factorBig < 0.9 || factorBig > 1.1)) {
return STROKE_DOTTED;
}
return STROKE_DASHED;
}
// not recognized ...
return STROKE_SOLID;
}
}