Subversion Repositories openrisc

/* BasicStroke.java --

   Copyright (C) 2002, 2003, 2004, 2005, 2006  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License

along with GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

package java.awt;

import gnu.java.awt.java2d.CubicSegment;

import gnu.java.awt.java2d.LineSegment;

import gnu.java.awt.java2d.QuadSegment;

import gnu.java.awt.java2d.Segment;

import java.awt.geom.FlatteningPathIterator;

import java.awt.geom.GeneralPath;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.Arrays;

/**

 * A general purpose {@link Stroke} implementation that can represent a wide

 * variety of line styles for use with subclasses of {@link Graphics2D}.

 * <p>

 * The line cap and join styles can be set using the options illustrated

 * here:

 * <p>

 * <img src="doc-files/capjoin.png" width="350" height="180"

 * alt="Illustration of line cap and join styles" />

 * <p>

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

  // The inner and outer paths of the stroke

  private Segment start, end;

  /**

   * Creates a new <code>BasicStroke</code> 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 <code>BasicStroke</code> 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 <code>BasicStroke</code> instance with the given attributes.

   * The miter limit defaults to <code>10.0</code>.

   *

   * @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 <code>BasicStroke</code> instance with the given line

   * width.  The default values are:

   * <ul>

   * <li>line cap style: {@link #CAP_SQUARE};</li>

   * <li>line join style: {@link #JOIN_MITER};</li>

   * <li>miter limit: <code>10.0f</code>.

   * </ul>

   *

   * @param width  the line width (>= 0.0f).

   *

   * @throws IllegalArgumentException If <code>width</code> is negative.

   */

  public BasicStroke(float width)

  {

    this(width, CAP_SQUARE, JOIN_MITER, 10, null, 0);

  }

  /**

   * Creates a new <code>BasicStroke</code> instance.  The default values are:

   * <ul>

   * <li>line width: <code>1.0f</code>;</li>

   * <li>line cap style: {@link #CAP_SQUARE};</li>

   * <li>line join style: {@link #JOIN_MITER};</li>

   * <li>miter limit: <code>10.0f</code>.

   * </ul>

   */

  public BasicStroke()

  {

    this(1, CAP_SQUARE, JOIN_MITER, 10, null, 0);

  }

  /**

   * Creates a shape representing the stroked outline of the given shape.

   * THIS METHOD IS NOT YET IMPLEMENTED.

   *

   * @param s  the shape.

   */

  public Shape createStrokedShape(Shape s)

  {

    PathIterator pi = s.getPathIterator(null);

    if( dash == null )

      return solidStroke( pi );

    return dashedStroke( pi );

  }

  /**

   * Returns the line width.

   *

   * @return The line width.

   */

  public float getLineWidth()

  {

    return width;

  }

  /**

   * Returns a code indicating the line cap style (one of {@link #CAP_BUTT},

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

   *

   * @return A code indicating the line cap style.

   */

  public int getEndCap()

  {

    return cap;

  }

  /**

   * Returns a code indicating the line join style (one of {@link #JOIN_BEVEL},

   * {@link #JOIN_MITER} or {@link #JOIN_ROUND}).

   *

   * @return A code indicating the line join style.

   */

  public int getLineJoin()

  {

    return join;

  }

  /**

   * Returns the miter limit.

   *

   * @return The miter limit.

   */

  public float getMiterLimit()

  {

    return limit;

  }

  /**

   * Returns the dash array, which defines the length of alternate opaque and

   * transparent sections in lines drawn with this stroke.  If

   * <code>null</code>, a continuous line will be drawn.

   *

   * @return The dash array (possibly <code>null</code>).

   */

  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 <code>int</code> first with

   * <code>Float.floatToIntBits()</code> if the value is a

   * <code>float</code>).

   *

   * @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 <code>BasicStroke</code> for equality with an arbitrary

   * object.  This method returns <code>true</code> if and only if:

   * <ul>

   * <li><code>o</code> is an instanceof <code>BasicStroke</code>;</li>

   * <li>this object has the same width, line cap style, line join style,

   * miter limit, dash array and dash phase as <code>o</code>.</li>

   * </ul>

   *

   * @param o  the object (<code>null</code> permitted).

   *

   * @return <code>true</code> if this stroke is equal to <code>o</code> and

   *         <code>false</code> 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;

  }

  private Shape solidStroke(PathIterator pi)

  {

    double[] coords = new double[6];

    double x, y, x0, y0;

    boolean pathOpen = false;

    GeneralPath output = new GeneralPath( );

    Segment[] p;

    x = x0 = y = y0 = 0;

    while( !pi.isDone() )

      {

        switch( pi.currentSegment(coords) )

          {

          case PathIterator.SEG_MOVETO:

            x0 = x = coords[0];

            y0 = y = coords[1];

            if( pathOpen )

              {

                capEnds();

                convertPath(output, start);

                start = end = null;

                pathOpen = false;

              }

            break;

          case PathIterator.SEG_LINETO:

            p = (new LineSegment(x, y, coords[0], coords[1])).

              getDisplacedSegments(width/2.0);

            if( !pathOpen )

              {

                start = p[0];

                end = p[1];

                pathOpen = true;

              }

            else

              addSegments(p);

            x = coords[0];

            y = coords[1];

            break;

          case PathIterator.SEG_QUADTO:

            p = (new QuadSegment(x, y, coords[0], coords[1], coords[2],

                                 coords[3])).getDisplacedSegments(width/2.0);

            if( !pathOpen )

              {

                start = p[0];

                end = p[1];

                pathOpen = true;

              }

            else

              addSegments(p);

            x = coords[2];

            y = coords[3];

            break;

          case PathIterator.SEG_CUBICTO:

            p = new CubicSegment(x, y, coords[0], coords[1],

                                 coords[2], coords[3],

                                 coords[4], coords[5]).getDisplacedSegments(width/2.0);

            if( !pathOpen )

              {

                start = p[0];

                end = p[1];

                pathOpen = true;

              }

            else

              addSegments(p);

            x = coords[4];

            y = coords[5];

            break;

          case PathIterator.SEG_CLOSE:

            if (x == x0 && y == y0)

              {

                joinSegments(new Segment[] { start.first, end.first });

              }

            else

              {

                p = (new LineSegment(x, y, x0, y0)).getDisplacedSegments(width / 2.0);

                addSegments(p);

              }

            convertPath(output, start);

            convertPath(output, end);

            start = end = null;

            pathOpen = false;

            output.setWindingRule(GeneralPath.WIND_EVEN_ODD);

            break;

          }

        pi.next();

      }

    if( pathOpen )

      {

        capEnds();

        convertPath(output, start);

      }

    return output;

  }

  private Shape dashedStroke(PathIterator pi)

  {

    // The choice of (flatnessSq == width / 3) is made to be consistent with

    // the flattening in CubicSegment.getDisplacedSegments

    FlatteningPathIterator flat = new FlatteningPathIterator(pi,

                                                             Math.sqrt(width / 3));

    // Holds the endpoint of the current segment (or piece of a segment)

    double[] coords = new double[2];

    // Holds end of the last segment

    double x, y, x0, y0;

    x = x0 = y = y0 = 0;

    // Various useful flags

    boolean pathOpen = false;

    boolean dashOn = true;

    boolean offsetting = (phase != 0);

    // How far we are into the current dash

    double distance = 0;

    int dashIndex = 0;

    // And variables to hold the final output

    GeneralPath output = new GeneralPath();

    Segment[] p;

    // Iterate over the FlatteningPathIterator

    while (! flat.isDone())

      {

        switch (flat.currentSegment(coords))

          {

          case PathIterator.SEG_MOVETO:

            x0 = x = coords[0];

            y0 = y = coords[1];

            if (pathOpen)

              {

                capEnds();

                convertPath(output, start);

                start = end = null;

                pathOpen = false;

              }

            break;

          case PathIterator.SEG_LINETO:

            boolean segmentConsumed = false;

            while (! segmentConsumed)

              {

                // Find the total remaining length of this segment

                double segLength = Math.sqrt((x - coords[0]) * (x - coords[0])

                                             + (y - coords[1])

                                             * (y - coords[1]));

                boolean spanBoundary = true;

                double[] segmentEnd = null;

                // The current segment fits entirely inside the current dash

                if ((offsetting && distance + segLength <= phase)

                    || distance + segLength <= dash[dashIndex])

                  {

                    spanBoundary = false;

                  }

                // Otherwise, we need to split the segment in two, as this

                // segment spans a dash boundry

                else

                  {

                    segmentEnd = (double[]) coords.clone();

                    // Calculate the remaining distance in this dash,

                    // and coordinates of the dash boundary

                    double reqLength;

                    if (offsetting)

                      reqLength = phase - distance;

                    else

                      reqLength = dash[dashIndex] - distance;

                    coords[0] = x + ((coords[0] - x) * reqLength / segLength);

                    coords[1] = y + ((coords[1] - y) * reqLength / segLength);

                  }

                if (offsetting || ! dashOn)

                  {

                    // Dash is off, or we are in offset - treat this as a

                    // moveTo

                    x0 = x = coords[0];

                    y0 = y = coords[1];

                    if (pathOpen)

                      {

                        capEnds();

                        convertPath(output, start);

                        start = end = null;

                        pathOpen = false;

                      }

                  }

                else

                  {

                    // Dash is on - treat this as a lineTo

                    p = (new LineSegment(x, y, coords[0], coords[1])).getDisplacedSegments(width / 2.0);

                    if (! pathOpen)

                      {

                        start = p[0];

                        end = p[1];

                        pathOpen = true;

                      }

                    else

                      addSegments(p);

                    x = coords[0];

                    y = coords[1];

                  }

                // Update variables depending on whether we spanned a

                // dash boundary or not

                if (! spanBoundary)

                  {

                    distance += segLength;

                    segmentConsumed = true;

                  }

                else

                  {

                    if (offsetting)

                      offsetting = false;

                    dashOn = ! dashOn;

                    distance = 0;

                    coords = segmentEnd;

                    if (dashIndex + 1 == dash.length)

                      dashIndex = 0;

                    else

                      dashIndex++;

                    // Since the value of segmentConsumed is still false,

                    // the next run of the while loop will complete the segment

                  }

              }

            break;

          // This is a flattened path, so we don't need to deal with curves

          }

        flat.next();

      }

    if (pathOpen)

      {

        capEnds();

        convertPath(output, start);

      }

    return output;

  }

  /**

   * Cap the ends of the path (joining the start and end list of segments)

   */

  private void capEnds()

  {

    Segment returnPath = end.last;

    end.reverseAll(); // reverse the path.

    end = null;

    capEnd(start, returnPath);

    start.last = returnPath.last;

    end = null;

    capEnd(start, start);

  }

  /**

   * Append the Segments in s to the GeneralPath p

   */

  private void convertPath(GeneralPath p, Segment s)

  {

    Segment v = s;

    p.moveTo((float)s.P1.getX(), (float)s.P1.getY());

    do

      {

        if(v instanceof LineSegment)

          p.lineTo((float)v.P2.getX(), (float)v.P2.getY());

        else if(v instanceof QuadSegment)

          p.quadTo((float)((QuadSegment)v).cp.getX(),

                   (float)((QuadSegment)v).cp.getY(),

                   (float)v.P2.getX(),

                   (float)v.P2.getY());

        else if(v instanceof CubicSegment)

          p.curveTo((float)((CubicSegment)v).cp1.getX(),

                    (float)((CubicSegment)v).cp1.getY(),

                    (float)((CubicSegment)v).cp2.getX(),

                    (float)((CubicSegment)v).cp2.getY(),

                    (float)v.P2.getX(),

                    (float)v.P2.getY());

        v = v.next;

      } while(v != s && v != null);

    p.closePath();

  }

  /**

   * Add the segments to start and end (the inner and outer edges of the stroke)

   */

  private void addSegments(Segment[] segments)

  {

    joinSegments(segments);

    start.add(segments[0]);

    end.add(segments[1]);

  }

  private void joinSegments(Segment[] segments)