/*

 * Copyright (c) 1997, 2010, 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 java.awt;

import java.beans.ConstructorProperties;

/**

 * The <code>BasicStroke</code> class defines a basic set of rendering

 * attributes for the outlines of graphics primitives, which are rendered

 * with a {@link Graphics2D} object that has its Stroke attribute set to

 * this <code>BasicStroke</code>.

 * The rendering attributes defined by <code>BasicStroke</code> describe

 * the shape of the mark made by a pen drawn along the outline of a

 * {@link Shape} and the decorations applied at the ends and joins of

 * path segments of the <code>Shape</code>.

 * These rendering attributes include:

 * <dl compact>

 * <dt><i>width</i>

 * <dd>The pen width, measured perpendicularly to the pen trajectory.

 * <dt><i>end caps</i>

 * <dd>The decoration applied to the ends of unclosed subpaths and

 * dash segments.  Subpaths that start and end on the same point are

 * still considered unclosed if they do not have a CLOSE segment.

 * See {@link java.awt.geom.PathIterator#SEG_CLOSE SEG_CLOSE}

 * for more information on the CLOSE segment.

 * The three different decorations are: {@link #CAP_BUTT},

 * {@link #CAP_ROUND}, and {@link #CAP_SQUARE}.

 * <dt><i>line joins</i>

 * <dd>The decoration applied at the intersection of two path segments

 * and at the intersection of the endpoints of a subpath that is closed

 * using {@link java.awt.geom.PathIterator#SEG_CLOSE SEG_CLOSE}.

 * The three different decorations are: {@link #JOIN_BEVEL},

 * {@link #JOIN_MITER}, and {@link #JOIN_ROUND}.

 * <dt><i>miter limit</i>

 * <dd>The limit to trim a line join that has a JOIN_MITER decoration.

 * A line join is trimmed when the ratio of miter length to stroke

 * width is greater than the miterlimit value.  The miter length is

 * the diagonal length of the miter, which is the distance between

 * the inside corner and the outside corner of the intersection.

 * The smaller the angle formed by two line segments, the longer

 * the miter length and the sharper the angle of intersection.  The

 * default miterlimit value of 10.0f causes all angles less than

 * 11 degrees to be trimmed.  Trimming miters converts

 * the decoration of the line join to bevel.

 * <dt><i>dash attributes</i>

 * <dd>The definition of how to make a dash pattern by alternating

 * between opaque and transparent sections.

 * </dl>

 * All attributes that specify measurements and distances controlling

 * the shape of the returned outline are measured in the same

 * coordinate system as the original unstroked <code>Shape</code>

 * argument.  When a <code>Graphics2D</code> object uses a

 * <code>Stroke</code> object to redefine a path during the execution

 * of one of its <code>draw</code> methods, the geometry is supplied

 * in its original form before the <code>Graphics2D</code> transform

 * attribute is applied.  Therefore, attributes such as the pen width

 * are interpreted in the user space coordinate system of the

 * <code>Graphics2D</code> object and are subject to the scaling and

 * shearing effects of the user-space-to-device-space transform in that

 * particular <code>Graphics2D</code>.

 * For example, the width of a rendered shape's outline is determined

 * not only by the width attribute of this <code>BasicStroke</code>,

 * but also by the transform attribute of the

 * <code>Graphics2D</code> object.  Consider this code:

 * <blockquote><tt>

 *      // sets the Graphics2D object's Tranform attribute

 *      g2d.scale(10, 10);

 *      // sets the Graphics2D object's Stroke attribute

 *      g2d.setStroke(new BasicStroke(1.5f));

 * </tt></blockquote>

 * Assuming there are no other scaling transforms added to the

 * <code>Graphics2D</code> object, the resulting line

 * will be approximately 15 pixels wide.

 * As the example code demonstrates, a floating-point line

 * offers better precision, especially when large transforms are

 * used with a <code>Graphics2D</code> object.

 * When a line is diagonal, the exact width depends on how the

 * rendering pipeline chooses which pixels to fill as it traces the

 * theoretical widened outline.  The choice of which pixels to turn

 * on is affected by the antialiasing attribute because the

 * antialiasing rendering pipeline can choose to color

 * partially-covered pixels.

 * <p>

 * For more information on the user space coordinate system and the

 * rendering process, see the <code>Graphics2D</code> class comments.

 * @see Graphics2D

 * @author Jim Graham

 */

public class BasicStroke implements Stroke {

    /**

     * Joins path segments by extending their outside edges until

     * they meet.

     */

    public final static int JOIN_MITER = 0;

    /**

     * Joins path segments by rounding off the corner at a radius

     * of half the line width.

     */

    public final static int JOIN_ROUND = 1;

    /**

     * Joins path segments by connecting the outer corners of their

     * wide outlines with a straight segment.

     */

    public final static int JOIN_BEVEL = 2;

    /**

     * Ends unclosed subpaths and dash segments with no added

     * decoration.

     */

    public final static int CAP_BUTT = 0;

    /**

     * Ends unclosed subpaths and dash segments with a round

     * decoration that has a radius equal to half of the width

     * of the pen.

     */

    public final static int CAP_ROUND = 1;

    /**

     * Ends unclosed subpaths and dash segments with a square

     * projection that extends beyond the end of the segment

     * to a distance equal to half of the line width.

     */

    public final static int CAP_SQUARE = 2;

    float width;

    int join;

    int cap;

    float miterlimit;

    float dash[];

    float dash_phase;

    /**

     * Constructs a new <code>BasicStroke</code> with the specified

     * attributes.

     * @param width the width of this <code>BasicStroke</code>.  The

     *         width must be greater than or equal to 0.0f.  If width is

     *         set to 0.0f, the stroke is rendered as the thinnest

     *         possible line for the target device and the antialias

     *         hint setting.

     * @param cap the decoration of the ends of a <code>BasicStroke</code>

     * @param join the decoration applied where path segments meet

     * @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

     * @param dash_phase the offset to start the dashing pattern

     * @throws IllegalArgumentException if <code>width</code> is negative

     * @throws IllegalArgumentException if <code>cap</code> is not either

     *         CAP_BUTT, CAP_ROUND or CAP_SQUARE

     * @throws IllegalArgumentException if <code>miterlimit</code> is less

     *         than 1 and <code>join</code> is JOIN_MITER

     * @throws IllegalArgumentException if <code>join</code> is not

     *         either JOIN_ROUND, JOIN_BEVEL, or JOIN_MITER

     * @throws IllegalArgumentException if <code>dash_phase</code>

     *         is negative and <code>dash</code> is not <code>null</code>

     * @throws IllegalArgumentException if the length of

     *         <code>dash</code> is zero

     * @throws IllegalArgumentException if dash lengths are all zero.

     */

    @ConstructorProperties({ "lineWidth", "endCap", "lineJoin", "miterLimit", "dashArray", "dashPhase" })

    public BasicStroke(float width, int cap, int join, float miterlimit,

                       float dash[], float dash_phase) {

        if (width < 0.0f) {

            throw new IllegalArgumentException("negative width");

        }

        if (cap != CAP_BUTT && cap != CAP_ROUND && cap != CAP_SQUARE) {

            throw new IllegalArgumentException("illegal end cap value");

        }

        if (join == JOIN_MITER) {

            if (miterlimit < 1.0f) {

                throw new IllegalArgumentException("miter limit < 1");

            }

        } else if (join != JOIN_ROUND && join != JOIN_BEVEL) {

            throw new IllegalArgumentException("illegal line join value");

        }

        if (dash != null) {

            if (dash_phase < 0.0f) {

                throw new IllegalArgumentException("negative dash phase");

            }

            boolean allzero = true;

            for (int i = 0; i < dash.length; i++) {

                float d = dash[i];

                if (d > 0.0) {

                    allzero = false;

                } else if (d < 0.0) {

                    throw new IllegalArgumentException("negative dash length");

                }

            }

            if (allzero) {

                throw new IllegalArgumentException("dash lengths all zero");

            }

        }

        this.width      = width;

        this.cap        = cap;

        this.join       = join;

        this.miterlimit = miterlimit;

        if (dash != null) {

            this.dash = (float []) dash.clone();

        }

        this.dash_phase = dash_phase;

    }

    /**

     * Constructs a solid <code>BasicStroke</code> with the specified

     * attributes.

     * @param width the width of the <code>BasicStroke</code>

     * @param cap the decoration of the ends of a <code>BasicStroke</code>

     * @param join the decoration applied where path segments meet

     * @param miterlimit the limit to trim the miter join

     * @throws IllegalArgumentException if <code>width</code> is negative

     * @throws IllegalArgumentException if <code>cap</code> is not either

     *         CAP_BUTT, CAP_ROUND or CAP_SQUARE

     * @throws IllegalArgumentException if <code>miterlimit</code> is less

     *         than 1 and <code>join</code> is JOIN_MITER

     * @throws IllegalArgumentException if <code>join</code> is not

     *         either JOIN_ROUND, JOIN_BEVEL, or JOIN_MITER

     */

    public BasicStroke(float width, int cap, int join, float miterlimit) {

        this(width, cap, join, miterlimit, null, 0.0f);

    }

    /**

     * Constructs a solid <code>BasicStroke</code> with the specified

     * attributes.  The <code>miterlimit</code> parameter is

     * unnecessary in cases where the default is allowable or the

     * line joins are not specified as JOIN_MITER.

     * @param width the width of the <code>BasicStroke</code>

     * @param cap the decoration of the ends of a <code>BasicStroke</code>

     * @param join the decoration applied where path segments meet

     * @throws IllegalArgumentException if <code>width</code> is negative

     * @throws IllegalArgumentException if <code>cap</code> is not either

     *         CAP_BUTT, CAP_ROUND or CAP_SQUARE

     * @throws IllegalArgumentException if <code>join</code> is not

     *         either JOIN_ROUND, JOIN_BEVEL, or JOIN_MITER

     */

    public BasicStroke(float width, int cap, int join) {

        this(width, cap, join, 10.0f, null, 0.0f);

    }

    /**

     * Constructs a solid <code>BasicStroke</code> with the specified

     * line width and with default values for the cap and join

     * styles.

     * @param width the width of the <code>BasicStroke</code>

     * @throws IllegalArgumentException if <code>width</code> is negative

     */

    public BasicStroke(float width) {

        this(width, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);

    }

    /**

     * Constructs a new <code>BasicStroke</code> with defaults for all

     * attributes.

     * The default attributes are a solid line of width 1.0, CAP_SQUARE,

     * JOIN_MITER, a miter limit of 10.0.

     */

    public BasicStroke() {

        this(1.0f, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);

    }

    /**

     * Returns a <code>Shape</code> whose interior defines the

     * stroked outline of a specified <code>Shape</code>.

     * @param s the <code>Shape</code> boundary be stroked

     * @return the <code>Shape</code> of the stroked outline.

     */

    public Shape createStrokedShape(Shape s) {

        sun.java2d.pipe.RenderingEngine re =

            sun.java2d.pipe.RenderingEngine.getInstance();

        return re.createStrokedShape(s, width, cap, join, miterlimit,

                                     dash, dash_phase);

    }

    /**

     * Returns the line width.  Line width is represented in user space,

     * which is the default-coordinate space used by Java 2D.  See the

     * <code>Graphics2D</code> class comments for more information on

     * the user space coordinate system.

     * @return the line width of this <code>BasicStroke</code>.

     * @see Graphics2D

     */

    public float getLineWidth() {

        return width;

    }

    /**

     * Returns the end cap style.

     * @return the end cap style of this <code>BasicStroke</code> as one

     * of the static <code>int</code> values that define possible end cap

     * styles.

     */

    public int getEndCap() {

        return cap;

    }

    /**

     * Returns the line join style.

     * @return the line join style of the <code>BasicStroke</code> as one

     * of the static <code>int</code> values that define possible line

     * join styles.

     */

    public int getLineJoin() {

        return join;

    }

    /**

     * Returns the limit of miter joins.

     * @return the limit of miter joins of the <code>BasicStroke</code>.

     */

    public float getMiterLimit() {

        return miterlimit;

    }

    /**

     * Returns the array representing the lengths of the dash segments.

     * Alternate entries in the array represent the user space lengths

     * of the opaque and transparent segments of the dashes.

     * As the pen moves along the outline of the <code>Shape</code>

     * to be stroked, the user space

     * distance that the pen travels is accumulated.  The distance

     * value is used to index into the dash array.

     * The pen is opaque when its current cumulative distance maps

     * to an even element of the dash array and transparent otherwise.

     * @return the dash array.

     */

    public float[] getDashArray() {

        if (dash == null) {

            return null;

        }

        return (float[]) dash.clone();

    }

    /**

     * Returns the current dash phase.

     * The dash phase is a distance specified in user coordinates that

     * represents an offset into the dashing pattern. In other words, the dash

     * phase defines the point in the dashing pattern that will correspond to

     * the beginning of the stroke.

     * @return the dash phase as a <code>float</code> value.

     */

    public float getDashPhase() {

        return dash_phase;

    }

    /**

     * Returns the hashcode for this stroke.

     * @return      a hash code for this stroke.

     */

    public int hashCode() {

        int hash = Float.floatToIntBits(width);

        hash = hash * 31 + join;

        hash = hash * 31 + cap;

        hash = hash * 31 + Float.floatToIntBits(miterlimit);

        if (dash != null) {

            hash = hash * 31 + Float.floatToIntBits(dash_phase);

            for (int i = 0; i < dash.length; i++) {

                hash = hash * 31 + Float.floatToIntBits(dash[i]);

            }

        }

        return hash;

    }

    /**

     * Returns true if this BasicStroke represents the same

     * stroking operation as the given argument.

     */

   /**

    * Tests if a specified object is equal to this <code>BasicStroke</code>

    * by first testing if it is a <code>BasicStroke</code> and then comparing

    * its width, join, cap, miter limit, dash, and dash phase attributes with

    * those of this <code>BasicStroke</code>.

    * @param  obj the specified object to compare to this

    *              <code>BasicStroke</code>

    * @return <code>true</code> if the width, join, cap, miter limit, dash, and

    *            dash phase are the same for both objects;

    *            <code>false</code> otherwise.

    */

    public boolean equals(Object obj) {

        if (!(obj instanceof BasicStroke)) {

            return false;

        }

        BasicStroke bs = (BasicStroke) obj;

        if (width != bs.width) {

            return false;

        }

        if (join != bs.join) {

            return false;

        }

        if (cap != bs.cap) {

            return false;

        }

        if (miterlimit != bs.miterlimit) {

            return false;

        }

        if (dash != null) {

            if (dash_phase != bs.dash_phase) {

                return false;

            }

            if (!java.util.Arrays.equals(dash, bs.dash)) {

                return false;

            }

        }

        else if (bs.dash != null) {

            return false;

        }

        return true;

    }

}