* * The line cap and join styles can be set using the options illustrated * here: *
*
*
* A dash array can be used to specify lines with alternating opaque and
* transparent sections.
*/
public class BasicStroke implements Stroke
{
/**
* Indicates a mitered line join style. See the class overview for an
* illustration.
*/
public static final int JOIN_MITER = 0;
/**
* Indicates a rounded line join style. See the class overview for an
* illustration.
*/
public static final int JOIN_ROUND = 1;
/**
* Indicates a bevelled line join style. See the class overview for an
* illustration.
*/
public static final int JOIN_BEVEL = 2;
/**
* Indicates a flat line cap style. See the class overview for an
* illustration.
*/
public static final int CAP_BUTT = 0;
/**
* Indicates a rounded line cap style. See the class overview for an
* illustration.
*/
public static final int CAP_ROUND = 1;
/**
* Indicates a square line cap style. See the class overview for an
* illustration.
*/
public static final int CAP_SQUARE = 2;
/** The stroke width. */
private final float width;
/** The line cap style. */
private final int cap;
/** The line join style. */
private final int join;
/** The miter limit. */
private final float limit;
/** The dash array. */
private final float[] dash;
/** The dash phase. */
private final float phase;
/**
* Creates a new BasicStroke instance with the given attributes.
*
* @param width the line width (>= 0.0f).
* @param cap the line cap style (one of {@link #CAP_BUTT},
* {@link #CAP_ROUND} or {@link #CAP_SQUARE}).
* @param join the line join style (one of {@link #JOIN_ROUND},
* {@link #JOIN_BEVEL}, or {@link #JOIN_MITER}).
* @param miterlimit the limit to trim the miter join. The miterlimit must be
* greater than or equal to 1.0f.
* @param dash The array representing the dashing pattern. There must be at
* least one non-zero entry.
* @param dashPhase is negative and dash is not null.
*
* @throws IllegalArgumentException If one input parameter doesn't meet
* its needs.
*/
public BasicStroke(float width, int cap, int join, float miterlimit,
float[] dash, float dashPhase)
{
if (width < 0.0f )
throw new IllegalArgumentException("width " + width + " < 0");
else if (cap < CAP_BUTT || cap > CAP_SQUARE)
throw new IllegalArgumentException("cap " + cap + " out of range ["
+ CAP_BUTT + ".." + CAP_SQUARE + "]");
else if (miterlimit < 1.0f && join == JOIN_MITER)
throw new IllegalArgumentException("miterlimit " + miterlimit
+ " < 1.0f while join == JOIN_MITER");
else if (join < JOIN_MITER || join > JOIN_BEVEL)
throw new IllegalArgumentException("join " + join + " out of range ["
+ JOIN_MITER + ".." + JOIN_BEVEL
+ "]");
else if (dashPhase < 0.0f && dash != null)
throw new IllegalArgumentException("dashPhase " + dashPhase
+ " < 0.0f while dash != null");
else if (dash != null)
if (dash.length == 0)
throw new IllegalArgumentException("dash.length is 0");
else
{
boolean allZero = true;
for ( int i = 0; i < dash.length; ++i)
{
if (dash[i] != 0.0f)
{
allZero = false;
break;
}
}
if (allZero)
throw new IllegalArgumentException("all dashes are 0.0f");
}
this.width = width;
this.cap = cap;
this.join = join;
limit = miterlimit;
this.dash = dash == null ? null : (float[]) dash.clone();
phase = dashPhase;
}
/**
* Creates a new BasicStroke instance with the given attributes.
*
* @param width the line width (>= 0.0f).
* @param cap the line cap style (one of {@link #CAP_BUTT},
* {@link #CAP_ROUND} or {@link #CAP_SQUARE}).
* @param join the line join style (one of {@link #JOIN_ROUND},
* {@link #JOIN_BEVEL}, or {@link #JOIN_MITER}).
* @param miterlimit the limit to trim the miter join. The miterlimit must be
* greater than or equal to 1.0f.
*
* @throws IllegalArgumentException If one input parameter doesn't meet
* its needs.
*/
public BasicStroke(float width, int cap, int join, float miterlimit)
{
this(width, cap, join, miterlimit, null, 0);
}
/**
* Creates a new BasicStroke instance with the given attributes.
* The miter limit defaults to 10.0.
*
* @param width the line width (>= 0.0f).
* @param cap the line cap style (one of {@link #CAP_BUTT},
* {@link #CAP_ROUND} or {@link #CAP_SQUARE}).
* @param join the line join style (one of {@link #JOIN_ROUND},
* {@link #JOIN_BEVEL}, or {@link #JOIN_MITER}).
*
* @throws IllegalArgumentException If one input parameter doesn't meet
* its needs.
*/
public BasicStroke(float width, int cap, int join)
{
this(width, cap, join, 10, null, 0);
}
/**
* Creates a new BasicStroke instance with the given line
* width. The default values are:
*
10.0f.
* width is negative.
*/
public BasicStroke(float width)
{
this(width, CAP_SQUARE, JOIN_MITER, 10, null, 0);
}
/**
* Creates a new BasicStroke instance. The default values are:
* 1.0f;10.0f.
* null, a continuous line will be drawn.
*
* @return The dash array (possibly null).
*/
public float[] getDashArray()
{
return dash;
}
/**
* Returns the dash phase for the stroke. This is the offset from the start
* of a path at which the pattern defined by {@link #getDashArray()} is
* rendered.
*
* @return The dash phase.
*/
public float getDashPhase()
{
return phase;
}
/**
* Returns the hash code for this object. The hash is calculated by
* xoring the hash, cap, join, limit, dash array and phase values
* (converted to int first with
* Float.floatToIntBits() if the value is a
* float).
*
* @return The hash code.
*/
public int hashCode()
{
int hash = Float.floatToIntBits(width);
hash ^= cap;
hash ^= join;
hash ^= Float.floatToIntBits(limit);
if (dash != null)
for (int i = 0; i < dash.length; i++)
hash ^= Float.floatToIntBits(dash[i]);
hash ^= Float.floatToIntBits(phase);
return hash;
}
/**
* Compares this BasicStroke for equality with an arbitrary
* object. This method returns true if and only if:
* o is an instanceof BasicStroke;o.null permitted).
*
* @return true if this stroke is equal to o and
* false otherwise.
*/
public boolean equals(Object o)
{
if (! (o instanceof BasicStroke))
return false;
BasicStroke s = (BasicStroke) o;
return width == s.width && cap == s.cap && join == s.join
&& limit == s.limit && Arrays.equals(dash, s.dash) && phase == s.phase;
}
}