1 /*
   2  * Copyright (c) 2006, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt.geom;
  27 
  28 import java.awt.Shape;
  29 import java.awt.Rectangle;
  30 import sun.awt.geom.Curve;
  31 import java.io.Serializable;
  32 import java.io.StreamCorruptedException;
  33 import java.util.Arrays;
  34 
  35 /**
  36  * The {@code Path2D} class provides a simple, yet flexible
  37  * shape which represents an arbitrary geometric path.
  38  * It can fully represent any path which can be iterated by the
  39  * {@link PathIterator} interface including all of its segment
  40  * types and winding rules and it implements all of the
  41  * basic hit testing methods of the {@link Shape} interface.
  42  * <p>
  43  * Use {@link Path2D.Float} when dealing with data that can be represented
  44  * and used with floating point precision.  Use {@link Path2D.Double}
  45  * for data that requires the accuracy or range of double precision.
  46  * <p>
  47  * {@code Path2D} provides exactly those facilities required for
  48  * basic construction and management of a geometric path and
  49  * implementation of the above interfaces with little added
  50  * interpretation.
  51  * If it is useful to manipulate the interiors of closed
  52  * geometric shapes beyond simple hit testing then the
  53  * {@link Area} class provides additional capabilities
  54  * specifically targeted at closed figures.
  55  * While both classes nominally implement the {@code Shape}
  56  * interface, they differ in purpose and together they provide
  57  * two useful views of a geometric shape where {@code Path2D}
  58  * deals primarily with a trajectory formed by path segments
  59  * and {@code Area} deals more with interpretation and manipulation
  60  * of enclosed regions of 2D geometric space.
  61  * <p>
  62  * The {@link PathIterator} interface has more detailed descriptions
  63  * of the types of segments that make up a path and the winding rules
  64  * that control how to determine which regions are inside or outside
  65  * the path.
  66  *
  67  * @author Jim Graham
  68  * @since 1.6
  69  */
  70 public abstract class Path2D implements Shape, Cloneable {
  71     /**
  72      * An even-odd winding rule for determining the interior of
  73      * a path.
  74      *
  75      * @see PathIterator#WIND_EVEN_ODD
  76      * @since 1.6
  77      */
  78     public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;
  79 
  80     /**
  81      * A non-zero winding rule for determining the interior of a
  82      * path.
  83      *
  84      * @see PathIterator#WIND_NON_ZERO
  85      * @since 1.6
  86      */
  87     public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;
  88 
  89     // For code simplicity, copy these constants to our namespace
  90     // and cast them to byte constants for easy storage.
  91     private static final byte SEG_MOVETO  = (byte) PathIterator.SEG_MOVETO;
  92     private static final byte SEG_LINETO  = (byte) PathIterator.SEG_LINETO;
  93     private static final byte SEG_QUADTO  = (byte) PathIterator.SEG_QUADTO;
  94     private static final byte SEG_CUBICTO = (byte) PathIterator.SEG_CUBICTO;
  95     private static final byte SEG_CLOSE   = (byte) PathIterator.SEG_CLOSE;
  96 
  97     transient byte[] pointTypes;
  98     transient int numTypes;
  99     transient int numCoords;
 100     transient int windingRule;
 101 
 102     static final int INIT_SIZE = 20;
 103     static final int EXPAND_MAX = 500;
 104     static final int EXPAND_MAX_COORDS = EXPAND_MAX * 2;
 105     static final int EXPAND_MIN = 10; // ensure > 6 (cubics)
 106 
 107     /**
 108      * Constructs a new empty {@code Path2D} object.
 109      * It is assumed that the package sibling subclass that is
 110      * defaulting to this constructor will fill in all values.
 111      *
 112      * @since 1.6
 113      */
 114     /* private protected */
 115     Path2D() {
 116     }
 117 
 118     /**
 119      * Constructs a new {@code Path2D} object from the given
 120      * specified initial values.
 121      * This method is only intended for internal use and should
 122      * not be made public if the other constructors for this class
 123      * are ever exposed.
 124      *
 125      * @param rule the winding rule
 126      * @param initialTypes the size to make the initial array to
 127      *                     store the path segment types
 128      * @since 1.6
 129      */
 130     /* private protected */
 131     Path2D(int rule, int initialTypes) {
 132         setWindingRule(rule);
 133         this.pointTypes = new byte[initialTypes];
 134     }
 135 
 136     abstract float[] cloneCoordsFloat(AffineTransform at);
 137     abstract double[] cloneCoordsDouble(AffineTransform at);
 138     abstract void append(float x, float y);
 139     abstract void append(double x, double y);
 140     abstract Point2D getPoint(int coordindex);
 141     abstract void needRoom(boolean needMove, int newCoords);
 142     abstract int pointCrossings(double px, double py);
 143     abstract int rectCrossings(double rxmin, double rymin,
 144                                double rxmax, double rymax);
 145 
 146     static byte[] expandPointTypes(byte[] oldPointTypes, int needed) {
 147         final int oldSize = oldPointTypes.length;
 148         final int newSizeMin = oldSize + needed;
 149         if (newSizeMin < oldSize) {
 150             // hard overflow failure - we can't even accommodate
 151             // new items without overflowing
 152             throw new ArrayIndexOutOfBoundsException(
 153                           "pointTypes exceeds maximum capacity !");
 154         }
 155         // growth algorithm computation
 156         int grow = oldSize;
 157         if (grow > EXPAND_MAX) {
 158             grow = Math.max(EXPAND_MAX, oldSize >> 3); // 1/8th min
 159         } else if (grow < EXPAND_MIN) {
 160             grow = EXPAND_MIN;
 161         }
 162         assert grow > 0;
 163 
 164         int newSize = oldSize + grow;
 165         if (newSize < newSizeMin) {
 166             // overflow in growth algorithm computation
 167             newSize = Integer.MAX_VALUE;
 168         }
 169         while (true) {
 170             try {
 171                 // try allocating the larger array
 172                 return Arrays.copyOf(oldPointTypes, newSize);
 173             } catch (OutOfMemoryError oome) {
 174                 if (newSize == newSizeMin) {
 175                     throw oome;
 176                 }
 177             }
 178             newSize = newSizeMin + (newSize - newSizeMin) / 2;
 179         }
 180     }
 181 
 182     /**
 183      * The {@code Float} class defines a geometric path with
 184      * coordinates stored in single precision floating point.
 185      *
 186      * @since 1.6
 187      */
 188     public static class Float extends Path2D implements Serializable {
 189         transient float floatCoords[];
 190 
 191         /**
 192          * Constructs a new empty single precision {@code Path2D} object
 193          * with a default winding rule of {@link #WIND_NON_ZERO}.
 194          *
 195          * @since 1.6
 196          */
 197         public Float() {
 198             this(WIND_NON_ZERO, INIT_SIZE);
 199         }
 200 
 201         /**
 202          * Constructs a new empty single precision {@code Path2D} object
 203          * with the specified winding rule to control operations that
 204          * require the interior of the path to be defined.
 205          *
 206          * @param rule the winding rule
 207          * @see #WIND_EVEN_ODD
 208          * @see #WIND_NON_ZERO
 209          * @since 1.6
 210          */
 211         public Float(int rule) {
 212             this(rule, INIT_SIZE);
 213         }
 214 
 215         /**
 216          * Constructs a new empty single precision {@code Path2D} object
 217          * with the specified winding rule and the specified initial
 218          * capacity to store path segments.
 219          * This number is an initial guess as to how many path segments
 220          * will be added to the path, but the storage is expanded as
 221          * needed to store whatever path segments are added.
 222          *
 223          * @param rule the winding rule
 224          * @param initialCapacity the estimate for the number of path segments
 225          *                        in the path
 226          * @see #WIND_EVEN_ODD
 227          * @see #WIND_NON_ZERO
 228          * @since 1.6
 229          */
 230         public Float(int rule, int initialCapacity) {
 231             super(rule, initialCapacity);
 232             floatCoords = new float[initialCapacity * 2];
 233         }
 234 
 235         /**
 236          * Constructs a new single precision {@code Path2D} object
 237          * from an arbitrary {@link Shape} object.
 238          * All of the initial geometry and the winding rule for this path are
 239          * taken from the specified {@code Shape} object.
 240          *
 241          * @param s the specified {@code Shape} object
 242          * @since 1.6
 243          */
 244         public Float(Shape s) {
 245             this(s, null);
 246         }
 247 
 248         /**
 249          * Constructs a new single precision {@code Path2D} object
 250          * from an arbitrary {@link Shape} object, transformed by an
 251          * {@link AffineTransform} object.
 252          * All of the initial geometry and the winding rule for this path are
 253          * taken from the specified {@code Shape} object and transformed
 254          * by the specified {@code AffineTransform} object.
 255          *
 256          * @param s the specified {@code Shape} object
 257          * @param at the specified {@code AffineTransform} object
 258          * @since 1.6
 259          */
 260         public Float(Shape s, AffineTransform at) {
 261             if (s instanceof Path2D) {
 262                 Path2D p2d = (Path2D) s;
 263                 setWindingRule(p2d.windingRule);
 264                 this.numTypes = p2d.numTypes;
 265                 // trim arrays:
 266                 this.pointTypes = Arrays.copyOf(p2d.pointTypes, p2d.numTypes);
 267                 this.numCoords = p2d.numCoords;
 268                 this.floatCoords = p2d.cloneCoordsFloat(at);
 269             } else {
 270                 PathIterator pi = s.getPathIterator(at);
 271                 setWindingRule(pi.getWindingRule());
 272                 this.pointTypes = new byte[INIT_SIZE];
 273                 this.floatCoords = new float[INIT_SIZE * 2];
 274                 append(pi, false);
 275             }
 276         }
 277 
 278         @Override
 279         public final Path2D trimToSize() {
 280             // trim arrays:
 281             if (numTypes < pointTypes.length) {
 282                 this.pointTypes = Arrays.copyOf(pointTypes, numTypes);
 283             }
 284             if (numCoords < floatCoords.length) {
 285                 this.floatCoords = Arrays.copyOf(floatCoords, numCoords);
 286             }
 287             return this;
 288         }
 289 
 290         @Override
 291         float[] cloneCoordsFloat(AffineTransform at) {
 292             // trim arrays:
 293             float ret[];
 294             if (at == null) {
 295                 ret = Arrays.copyOf(floatCoords, numCoords);
 296             } else {
 297                 ret = new float[numCoords];
 298                 at.transform(floatCoords, 0, ret, 0, numCoords / 2);
 299             }
 300             return ret;
 301         }
 302 
 303         @Override
 304         double[] cloneCoordsDouble(AffineTransform at) {
 305             // trim arrays:
 306             double ret[] = new double[numCoords];
 307             if (at == null) {
 308                 for (int i = 0; i < numCoords; i++) {
 309                     ret[i] = floatCoords[i];
 310                 }
 311             } else {
 312                 at.transform(floatCoords, 0, ret, 0, numCoords / 2);
 313             }
 314             return ret;
 315         }
 316 
 317         void append(float x, float y) {
 318             floatCoords[numCoords++] = x;
 319             floatCoords[numCoords++] = y;
 320         }
 321 
 322         void append(double x, double y) {
 323             floatCoords[numCoords++] = (float) x;
 324             floatCoords[numCoords++] = (float) y;
 325         }
 326 
 327         Point2D getPoint(int coordindex) {
 328             return new Point2D.Float(floatCoords[coordindex],
 329                                      floatCoords[coordindex+1]);
 330         }
 331 
 332         @Override
 333         void needRoom(boolean needMove, int newCoords) {
 334             if ((numTypes == 0) && needMove) {
 335                 throw new IllegalPathStateException("missing initial moveto "+
 336                                                     "in path definition");
 337             }
 338             if (numTypes >= pointTypes.length) {
 339                 pointTypes = expandPointTypes(pointTypes, 1);
 340             }
 341             if (numCoords > (floatCoords.length - newCoords)) {
 342                 floatCoords = expandCoords(floatCoords, newCoords);
 343             }
 344         }
 345 
 346         static float[] expandCoords(float[] oldCoords, int needed) {
 347             final int oldSize = oldCoords.length;
 348             final int newSizeMin = oldSize + needed;
 349             if (newSizeMin < oldSize) {
 350                 // hard overflow failure - we can't even accommodate
 351                 // new items without overflowing
 352                 throw new ArrayIndexOutOfBoundsException(
 353                               "coords exceeds maximum capacity !");
 354             }
 355             // growth algorithm computation
 356             int grow = oldSize;
 357             if (grow > EXPAND_MAX_COORDS) {
 358                 grow = Math.max(EXPAND_MAX_COORDS, oldSize >> 3); // 1/8th min
 359             } else if (grow < EXPAND_MIN) {
 360                 grow = EXPAND_MIN;
 361             }
 362             assert grow > needed;
 363 
 364             int newSize = oldSize + grow;
 365             if (newSize < newSizeMin) {
 366                 // overflow in growth algorithm computation
 367                 newSize = Integer.MAX_VALUE;
 368             }
 369             while (true) {
 370                 try {
 371                     // try allocating the larger array
 372                     return Arrays.copyOf(oldCoords, newSize);
 373                 } catch (OutOfMemoryError oome) {
 374                     if (newSize == newSizeMin) {
 375                         throw oome;
 376                     }
 377                 }
 378                 newSize = newSizeMin + (newSize - newSizeMin) / 2;
 379             }
 380         }
 381 
 382         /**
 383          * {@inheritDoc}
 384          * @since 1.6
 385          */
 386         public final synchronized void moveTo(double x, double y) {
 387             if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
 388                 floatCoords[numCoords-2] = (float) x;
 389                 floatCoords[numCoords-1] = (float) y;
 390             } else {
 391                 needRoom(false, 2);
 392                 pointTypes[numTypes++] = SEG_MOVETO;
 393                 floatCoords[numCoords++] = (float) x;
 394                 floatCoords[numCoords++] = (float) y;
 395             }
 396         }
 397 
 398         /**
 399          * Adds a point to the path by moving to the specified
 400          * coordinates specified in float precision.
 401          * <p>
 402          * This method provides a single precision variant of
 403          * the double precision {@code moveTo()} method on the
 404          * base {@code Path2D} class.
 405          *
 406          * @param x the specified X coordinate
 407          * @param y the specified Y coordinate
 408          * @see Path2D#moveTo
 409          * @since 1.6
 410          */
 411         public final synchronized void moveTo(float x, float y) {
 412             if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
 413                 floatCoords[numCoords-2] = x;
 414                 floatCoords[numCoords-1] = y;
 415             } else {
 416                 needRoom(false, 2);
 417                 pointTypes[numTypes++] = SEG_MOVETO;
 418                 floatCoords[numCoords++] = x;
 419                 floatCoords[numCoords++] = y;
 420             }
 421         }
 422 
 423         /**
 424          * {@inheritDoc}
 425          * @since 1.6
 426          */
 427         public final synchronized void lineTo(double x, double y) {
 428             needRoom(true, 2);
 429             pointTypes[numTypes++] = SEG_LINETO;
 430             floatCoords[numCoords++] = (float) x;
 431             floatCoords[numCoords++] = (float) y;
 432         }
 433 
 434         /**
 435          * Adds a point to the path by drawing a straight line from the
 436          * current coordinates to the new specified coordinates
 437          * specified in float precision.
 438          * <p>
 439          * This method provides a single precision variant of
 440          * the double precision {@code lineTo()} method on the
 441          * base {@code Path2D} class.
 442          *
 443          * @param x the specified X coordinate
 444          * @param y the specified Y coordinate
 445          * @see Path2D#lineTo
 446          * @since 1.6
 447          */
 448         public final synchronized void lineTo(float x, float y) {
 449             needRoom(true, 2);
 450             pointTypes[numTypes++] = SEG_LINETO;
 451             floatCoords[numCoords++] = x;
 452             floatCoords[numCoords++] = y;
 453         }
 454 
 455         /**
 456          * {@inheritDoc}
 457          * @since 1.6
 458          */
 459         public final synchronized void quadTo(double x1, double y1,
 460                                               double x2, double y2)
 461         {
 462             needRoom(true, 4);
 463             pointTypes[numTypes++] = SEG_QUADTO;
 464             floatCoords[numCoords++] = (float) x1;
 465             floatCoords[numCoords++] = (float) y1;
 466             floatCoords[numCoords++] = (float) x2;
 467             floatCoords[numCoords++] = (float) y2;
 468         }
 469 
 470         /**
 471          * Adds a curved segment, defined by two new points, to the path by
 472          * drawing a Quadratic curve that intersects both the current
 473          * coordinates and the specified coordinates {@code (x2,y2)},
 474          * using the specified point {@code (x1,y1)} as a quadratic
 475          * parametric control point.
 476          * All coordinates are specified in float precision.
 477          * <p>
 478          * This method provides a single precision variant of
 479          * the double precision {@code quadTo()} method on the
 480          * base {@code Path2D} class.
 481          *
 482          * @param x1 the X coordinate of the quadratic control point
 483          * @param y1 the Y coordinate of the quadratic control point
 484          * @param x2 the X coordinate of the final end point
 485          * @param y2 the Y coordinate of the final end point
 486          * @see Path2D#quadTo
 487          * @since 1.6
 488          */
 489         public final synchronized void quadTo(float x1, float y1,
 490                                               float x2, float y2)
 491         {
 492             needRoom(true, 4);
 493             pointTypes[numTypes++] = SEG_QUADTO;
 494             floatCoords[numCoords++] = x1;
 495             floatCoords[numCoords++] = y1;
 496             floatCoords[numCoords++] = x2;
 497             floatCoords[numCoords++] = y2;
 498         }
 499 
 500         /**
 501          * {@inheritDoc}
 502          * @since 1.6
 503          */
 504         public final synchronized void curveTo(double x1, double y1,
 505                                                double x2, double y2,
 506                                                double x3, double y3)
 507         {
 508             needRoom(true, 6);
 509             pointTypes[numTypes++] = SEG_CUBICTO;
 510             floatCoords[numCoords++] = (float) x1;
 511             floatCoords[numCoords++] = (float) y1;
 512             floatCoords[numCoords++] = (float) x2;
 513             floatCoords[numCoords++] = (float) y2;
 514             floatCoords[numCoords++] = (float) x3;
 515             floatCoords[numCoords++] = (float) y3;
 516         }
 517 
 518         /**
 519          * Adds a curved segment, defined by three new points, to the path by
 520          * drawing a B&eacute;zier curve that intersects both the current
 521          * coordinates and the specified coordinates {@code (x3,y3)},
 522          * using the specified points {@code (x1,y1)} and {@code (x2,y2)} as
 523          * B&eacute;zier control points.
 524          * All coordinates are specified in float precision.
 525          * <p>
 526          * This method provides a single precision variant of
 527          * the double precision {@code curveTo()} method on the
 528          * base {@code Path2D} class.
 529          *
 530          * @param x1 the X coordinate of the first B&eacute;zier control point
 531          * @param y1 the Y coordinate of the first B&eacute;zier control point
 532          * @param x2 the X coordinate of the second B&eacute;zier control point
 533          * @param y2 the Y coordinate of the second B&eacute;zier control point
 534          * @param x3 the X coordinate of the final end point
 535          * @param y3 the Y coordinate of the final end point
 536          * @see Path2D#curveTo
 537          * @since 1.6
 538          */
 539         public final synchronized void curveTo(float x1, float y1,
 540                                                float x2, float y2,
 541                                                float x3, float y3)
 542         {
 543             needRoom(true, 6);
 544             pointTypes[numTypes++] = SEG_CUBICTO;
 545             floatCoords[numCoords++] = x1;
 546             floatCoords[numCoords++] = y1;
 547             floatCoords[numCoords++] = x2;
 548             floatCoords[numCoords++] = y2;
 549             floatCoords[numCoords++] = x3;
 550             floatCoords[numCoords++] = y3;
 551         }
 552 
 553         int pointCrossings(double px, double py) {
 554             if (numTypes == 0) {
 555                 return 0;
 556             }
 557             double movx, movy, curx, cury, endx, endy;
 558             float coords[] = floatCoords;
 559             curx = movx = coords[0];
 560             cury = movy = coords[1];
 561             int crossings = 0;
 562             int ci = 2;
 563             for (int i = 1; i < numTypes; i++) {
 564                 switch (pointTypes[i]) {
 565                 case PathIterator.SEG_MOVETO:
 566                     if (cury != movy) {
 567                         crossings +=
 568                             Curve.pointCrossingsForLine(px, py,
 569                                                         curx, cury,
 570                                                         movx, movy);
 571                     }
 572                     movx = curx = coords[ci++];
 573                     movy = cury = coords[ci++];
 574                     break;
 575                 case PathIterator.SEG_LINETO:
 576                     crossings +=
 577                         Curve.pointCrossingsForLine(px, py,
 578                                                     curx, cury,
 579                                                     endx = coords[ci++],
 580                                                     endy = coords[ci++]);
 581                     curx = endx;
 582                     cury = endy;
 583                     break;
 584                 case PathIterator.SEG_QUADTO:
 585                     crossings +=
 586                         Curve.pointCrossingsForQuad(px, py,
 587                                                     curx, cury,
 588                                                     coords[ci++],
 589                                                     coords[ci++],
 590                                                     endx = coords[ci++],
 591                                                     endy = coords[ci++],
 592                                                     0);
 593                     curx = endx;
 594                     cury = endy;
 595                     break;
 596             case PathIterator.SEG_CUBICTO:
 597                     crossings +=
 598                         Curve.pointCrossingsForCubic(px, py,
 599                                                      curx, cury,
 600                                                      coords[ci++],
 601                                                      coords[ci++],
 602                                                      coords[ci++],
 603                                                      coords[ci++],
 604                                                      endx = coords[ci++],
 605                                                      endy = coords[ci++],
 606                                                      0);
 607                     curx = endx;
 608                     cury = endy;
 609                     break;
 610                 case PathIterator.SEG_CLOSE:
 611                     if (cury != movy) {
 612                         crossings +=
 613                             Curve.pointCrossingsForLine(px, py,
 614                                                         curx, cury,
 615                                                         movx, movy);
 616                     }
 617                     curx = movx;
 618                     cury = movy;
 619                     break;
 620                 }
 621             }
 622             if (cury != movy) {
 623                 crossings +=
 624                     Curve.pointCrossingsForLine(px, py,
 625                                                 curx, cury,
 626                                                 movx, movy);
 627             }
 628             return crossings;
 629         }
 630 
 631         int rectCrossings(double rxmin, double rymin,
 632                           double rxmax, double rymax)
 633         {
 634             if (numTypes == 0) {
 635                 return 0;
 636             }
 637             float coords[] = floatCoords;
 638             double curx, cury, movx, movy, endx, endy;
 639             curx = movx = coords[0];
 640             cury = movy = coords[1];
 641             int crossings = 0;
 642             int ci = 2;
 643             for (int i = 1;
 644                  crossings != Curve.RECT_INTERSECTS && i < numTypes;
 645                  i++)
 646             {
 647                 switch (pointTypes[i]) {
 648                 case PathIterator.SEG_MOVETO:
 649                     if (curx != movx || cury != movy) {
 650                         crossings =
 651                             Curve.rectCrossingsForLine(crossings,
 652                                                        rxmin, rymin,
 653                                                        rxmax, rymax,
 654                                                        curx, cury,
 655                                                        movx, movy);
 656                     }
 657                     // Count should always be a multiple of 2 here.
 658                     // assert((crossings & 1) != 0);
 659                     movx = curx = coords[ci++];
 660                     movy = cury = coords[ci++];
 661                     break;
 662                 case PathIterator.SEG_LINETO:
 663                     crossings =
 664                         Curve.rectCrossingsForLine(crossings,
 665                                                    rxmin, rymin,
 666                                                    rxmax, rymax,
 667                                                    curx, cury,
 668                                                    endx = coords[ci++],
 669                                                    endy = coords[ci++]);
 670                     curx = endx;
 671                     cury = endy;
 672                     break;
 673                 case PathIterator.SEG_QUADTO:
 674                     crossings =
 675                         Curve.rectCrossingsForQuad(crossings,
 676                                                    rxmin, rymin,
 677                                                    rxmax, rymax,
 678                                                    curx, cury,
 679                                                    coords[ci++],
 680                                                    coords[ci++],
 681                                                    endx = coords[ci++],
 682                                                    endy = coords[ci++],
 683                                                    0);
 684                     curx = endx;
 685                     cury = endy;
 686                     break;
 687                 case PathIterator.SEG_CUBICTO:
 688                     crossings =
 689                         Curve.rectCrossingsForCubic(crossings,
 690                                                     rxmin, rymin,
 691                                                     rxmax, rymax,
 692                                                     curx, cury,
 693                                                     coords[ci++],
 694                                                     coords[ci++],
 695                                                     coords[ci++],
 696                                                     coords[ci++],
 697                                                     endx = coords[ci++],
 698                                                     endy = coords[ci++],
 699                                                     0);
 700                     curx = endx;
 701                     cury = endy;
 702                     break;
 703                 case PathIterator.SEG_CLOSE:
 704                     if (curx != movx || cury != movy) {
 705                         crossings =
 706                             Curve.rectCrossingsForLine(crossings,
 707                                                        rxmin, rymin,
 708                                                        rxmax, rymax,
 709                                                        curx, cury,
 710                                                        movx, movy);
 711                     }
 712                     curx = movx;
 713                     cury = movy;
 714                     // Count should always be a multiple of 2 here.
 715                     // assert((crossings & 1) != 0);
 716                     break;
 717                 }
 718             }
 719             if (crossings != Curve.RECT_INTERSECTS &&
 720                 (curx != movx || cury != movy))
 721             {
 722                 crossings =
 723                     Curve.rectCrossingsForLine(crossings,
 724                                                rxmin, rymin,
 725                                                rxmax, rymax,
 726                                                curx, cury,
 727                                                movx, movy);
 728             }
 729             // Count should always be a multiple of 2 here.
 730             // assert((crossings & 1) != 0);
 731             return crossings;
 732         }
 733 
 734         /**
 735          * {@inheritDoc}
 736          * @since 1.6
 737          */
 738         public final void append(PathIterator pi, boolean connect) {
 739             float coords[] = new float[6];
 740             while (!pi.isDone()) {
 741                 switch (pi.currentSegment(coords)) {
 742                 case SEG_MOVETO:
 743                     if (!connect || numTypes < 1 || numCoords < 1) {
 744                         moveTo(coords[0], coords[1]);
 745                         break;
 746                     }
 747                     if (pointTypes[numTypes - 1] != SEG_CLOSE &&
 748                         floatCoords[numCoords-2] == coords[0] &&
 749                         floatCoords[numCoords-1] == coords[1])
 750                     {
 751                         // Collapse out initial moveto/lineto
 752                         break;
 753                     }
 754                     lineTo(coords[0], coords[1]);
 755                     break;
 756                 case SEG_LINETO:
 757                     lineTo(coords[0], coords[1]);
 758                     break;
 759                 case SEG_QUADTO:
 760                     quadTo(coords[0], coords[1],
 761                            coords[2], coords[3]);
 762                     break;
 763                 case SEG_CUBICTO:
 764                     curveTo(coords[0], coords[1],
 765                             coords[2], coords[3],
 766                             coords[4], coords[5]);
 767                     break;
 768                 case SEG_CLOSE:
 769                     closePath();
 770                     break;
 771                 }
 772                 pi.next();
 773                 connect = false;
 774             }
 775         }
 776 
 777         /**
 778          * {@inheritDoc}
 779          * @since 1.6
 780          */
 781         public final void transform(AffineTransform at) {
 782             at.transform(floatCoords, 0, floatCoords, 0, numCoords / 2);
 783         }
 784 
 785         /**
 786          * {@inheritDoc}
 787          * @since 1.6
 788          */
 789         public final synchronized Rectangle2D getBounds2D() {
 790             float x1, y1, x2, y2;
 791             int i = numCoords;
 792             if (i > 0) {
 793                 y1 = y2 = floatCoords[--i];
 794                 x1 = x2 = floatCoords[--i];
 795                 while (i > 0) {
 796                     float y = floatCoords[--i];
 797                     float x = floatCoords[--i];
 798                     if (x < x1) x1 = x;
 799                     if (y < y1) y1 = y;
 800                     if (x > x2) x2 = x;
 801                     if (y > y2) y2 = y;
 802                 }
 803             } else {
 804                 x1 = y1 = x2 = y2 = 0.0f;
 805             }
 806             return new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1);
 807         }
 808 
 809         /**
 810          * {@inheritDoc}
 811          * <p>
 812          * The iterator for this class is not multi-threaded safe,
 813          * which means that the {@code Path2D} class does not
 814          * guarantee that modifications to the geometry of this
 815          * {@code Path2D} object do not affect any iterations of
 816          * that geometry that are already in process.
 817          *
 818          * @since 1.6
 819          */
 820         public final PathIterator getPathIterator(AffineTransform at) {
 821             if (at == null) {
 822                 return new CopyIterator(this);
 823             } else {
 824                 return new TxIterator(this, at);
 825             }
 826         }
 827 
 828         /**
 829          * Creates a new object of the same class as this object.
 830          *
 831          * @return     a clone of this instance.
 832          * @exception  OutOfMemoryError    if there is not enough memory.
 833          * @see        java.lang.Cloneable
 834          * @since      1.6
 835          */
 836         public final Object clone() {
 837             // Note: It would be nice to have this return Path2D
 838             // but one of our subclasses (GeneralPath) needs to
 839             // offer "public Object clone()" for backwards
 840             // compatibility so we cannot restrict it further.
 841             // REMIND: Can we do both somehow?
 842             if (this instanceof GeneralPath) {
 843                 return new GeneralPath(this);
 844             } else {
 845                 return new Path2D.Float(this);
 846             }
 847         }
 848 
 849         /*
 850          * JDK 1.6 serialVersionUID
 851          */
 852         private static final long serialVersionUID = 6990832515060788886L;
 853 
 854         /**
 855          * Writes the default serializable fields to the
 856          * {@code ObjectOutputStream} followed by an explicit
 857          * serialization of the path segments stored in this
 858          * path.
 859          *
 860          * @serialData
 861          * <a name="Path2DSerialData"><!-- --></a>
 862          * <ol>
 863          * <li>The default serializable fields.
 864          * There are no default serializable fields as of 1.6.
 865          * <li>followed by
 866          * a byte indicating the storage type of the original object
 867          * as a hint (SERIAL_STORAGE_FLT_ARRAY)
 868          * <li>followed by
 869          * an integer indicating the number of path segments to follow (NP)
 870          * or -1 to indicate an unknown number of path segments follows
 871          * <li>followed by
 872          * an integer indicating the total number of coordinates to follow (NC)
 873          * or -1 to indicate an unknown number of coordinates follows
 874          * (NC should always be even since coordinates always appear in pairs
 875          *  representing an x,y pair)
 876          * <li>followed by
 877          * a byte indicating the winding rule
 878          * ({@link #WIND_EVEN_ODD WIND_EVEN_ODD} or
 879          *  {@link #WIND_NON_ZERO WIND_NON_ZERO})
 880          * <li>followed by
 881          * {@code NP} (or unlimited if {@code NP < 0}) sets of values consisting of
 882          * a single byte indicating a path segment type
 883          * followed by one or more pairs of float or double
 884          * values representing the coordinates of the path segment
 885          * <li>followed by
 886          * a byte indicating the end of the path (SERIAL_PATH_END).
 887          * </ol>
 888          * <p>
 889          * The following byte value constants are used in the serialized form
 890          * of {@code Path2D} objects:
 891          * <table>
 892          * <tr>
 893          * <th>Constant Name</th>
 894          * <th>Byte Value</th>
 895          * <th>Followed by</th>
 896          * <th>Description</th>
 897          * </tr>
 898          * <tr>
 899          * <td>{@code SERIAL_STORAGE_FLT_ARRAY}</td>
 900          * <td>0x30</td>
 901          * <td></td>
 902          * <td>A hint that the original {@code Path2D} object stored
 903          * the coordinates in a Java array of floats.</td>
 904          * </tr>
 905          * <tr>
 906          * <td>{@code SERIAL_STORAGE_DBL_ARRAY}</td>
 907          * <td>0x31</td>
 908          * <td></td>
 909          * <td>A hint that the original {@code Path2D} object stored
 910          * the coordinates in a Java array of doubles.</td>
 911          * </tr>
 912          * <tr>
 913          * <td>{@code SERIAL_SEG_FLT_MOVETO}</td>
 914          * <td>0x40</td>
 915          * <td>2 floats</td>
 916          * <td>A {@link #moveTo moveTo} path segment follows.</td>
 917          * </tr>
 918          * <tr>
 919          * <td>{@code SERIAL_SEG_FLT_LINETO}</td>
 920          * <td>0x41</td>
 921          * <td>2 floats</td>
 922          * <td>A {@link #lineTo lineTo} path segment follows.</td>
 923          * </tr>
 924          * <tr>
 925          * <td>{@code SERIAL_SEG_FLT_QUADTO}</td>
 926          * <td>0x42</td>
 927          * <td>4 floats</td>
 928          * <td>A {@link #quadTo quadTo} path segment follows.</td>
 929          * </tr>
 930          * <tr>
 931          * <td>{@code SERIAL_SEG_FLT_CUBICTO}</td>
 932          * <td>0x43</td>
 933          * <td>6 floats</td>
 934          * <td>A {@link #curveTo curveTo} path segment follows.</td>
 935          * </tr>
 936          * <tr>
 937          * <td>{@code SERIAL_SEG_DBL_MOVETO}</td>
 938          * <td>0x50</td>
 939          * <td>2 doubles</td>
 940          * <td>A {@link #moveTo moveTo} path segment follows.</td>
 941          * </tr>
 942          * <tr>
 943          * <td>{@code SERIAL_SEG_DBL_LINETO}</td>
 944          * <td>0x51</td>
 945          * <td>2 doubles</td>
 946          * <td>A {@link #lineTo lineTo} path segment follows.</td>
 947          * </tr>
 948          * <tr>
 949          * <td>{@code SERIAL_SEG_DBL_QUADTO}</td>
 950          * <td>0x52</td>
 951          * <td>4 doubles</td>
 952          * <td>A {@link #curveTo curveTo} path segment follows.</td>
 953          * </tr>
 954          * <tr>
 955          * <td>{@code SERIAL_SEG_DBL_CUBICTO}</td>
 956          * <td>0x53</td>
 957          * <td>6 doubles</td>
 958          * <td>A {@link #curveTo curveTo} path segment follows.</td>
 959          * </tr>
 960          * <tr>
 961          * <td>{@code SERIAL_SEG_CLOSE}</td>
 962          * <td>0x60</td>
 963          * <td></td>
 964          * <td>A {@link #closePath closePath} path segment.</td>
 965          * </tr>
 966          * <tr>
 967          * <td>{@code SERIAL_PATH_END}</td>
 968          * <td>0x61</td>
 969          * <td></td>
 970          * <td>There are no more path segments following.</td>
 971          * </table>
 972          *
 973          * @since 1.6
 974          */
 975         private void writeObject(java.io.ObjectOutputStream s)
 976             throws java.io.IOException
 977         {
 978             super.writeObject(s, false);
 979         }
 980 
 981         /**
 982          * Reads the default serializable fields from the
 983          * {@code ObjectInputStream} followed by an explicit
 984          * serialization of the path segments stored in this
 985          * path.
 986          * <p>
 987          * There are no default serializable fields as of 1.6.
 988          * <p>
 989          * The serial data for this object is described in the
 990          * writeObject method.
 991          *
 992          * @since 1.6
 993          */
 994         private void readObject(java.io.ObjectInputStream s)
 995             throws java.lang.ClassNotFoundException, java.io.IOException
 996         {
 997             super.readObject(s, false);
 998         }
 999 
1000         static class CopyIterator extends Path2D.Iterator {
1001             float floatCoords[];
1002 
1003             CopyIterator(Path2D.Float p2df) {
1004                 super(p2df);
1005                 this.floatCoords = p2df.floatCoords;
1006             }
1007 
1008             public int currentSegment(float[] coords) {
1009                 int type = path.pointTypes[typeIdx];
1010                 int numCoords = curvecoords[type];
1011                 if (numCoords > 0) {
1012                     System.arraycopy(floatCoords, pointIdx,
1013                                      coords, 0, numCoords);
1014                 }
1015                 return type;
1016             }
1017 
1018             public int currentSegment(double[] coords) {
1019                 int type = path.pointTypes[typeIdx];
1020                 int numCoords = curvecoords[type];
1021                 if (numCoords > 0) {
1022                     for (int i = 0; i < numCoords; i++) {
1023                         coords[i] = floatCoords[pointIdx + i];
1024                     }
1025                 }
1026                 return type;
1027             }
1028         }
1029 
1030         static class TxIterator extends Path2D.Iterator {
1031             float floatCoords[];
1032             AffineTransform affine;
1033 
1034             TxIterator(Path2D.Float p2df, AffineTransform at) {
1035                 super(p2df);
1036                 this.floatCoords = p2df.floatCoords;
1037                 this.affine = at;
1038             }
1039 
1040             public int currentSegment(float[] coords) {
1041                 int type = path.pointTypes[typeIdx];
1042                 int numCoords = curvecoords[type];
1043                 if (numCoords > 0) {
1044                     affine.transform(floatCoords, pointIdx,
1045                                      coords, 0, numCoords / 2);
1046                 }
1047                 return type;
1048             }
1049 
1050             public int currentSegment(double[] coords) {
1051                 int type = path.pointTypes[typeIdx];
1052                 int numCoords = curvecoords[type];
1053                 if (numCoords > 0) {
1054                     affine.transform(floatCoords, pointIdx,
1055                                      coords, 0, numCoords / 2);
1056                 }
1057                 return type;
1058             }
1059         }
1060 
1061     }
1062 
1063     /**
1064      * The {@code Double} class defines a geometric path with
1065      * coordinates stored in double precision floating point.
1066      *
1067      * @since 1.6
1068      */
1069     public static class Double extends Path2D implements Serializable {
1070         transient double doubleCoords[];
1071 
1072         /**
1073          * Constructs a new empty double precision {@code Path2D} object
1074          * with a default winding rule of {@link #WIND_NON_ZERO}.
1075          *
1076          * @since 1.6
1077          */
1078         public Double() {
1079             this(WIND_NON_ZERO, INIT_SIZE);
1080         }
1081 
1082         /**
1083          * Constructs a new empty double precision {@code Path2D} object
1084          * with the specified winding rule to control operations that
1085          * require the interior of the path to be defined.
1086          *
1087          * @param rule the winding rule
1088          * @see #WIND_EVEN_ODD
1089          * @see #WIND_NON_ZERO
1090          * @since 1.6
1091          */
1092         public Double(int rule) {
1093             this(rule, INIT_SIZE);
1094         }
1095 
1096         /**
1097          * Constructs a new empty double precision {@code Path2D} object
1098          * with the specified winding rule and the specified initial
1099          * capacity to store path segments.
1100          * This number is an initial guess as to how many path segments
1101          * are in the path, but the storage is expanded as needed to store
1102          * whatever path segments are added to this path.
1103          *
1104          * @param rule the winding rule
1105          * @param initialCapacity the estimate for the number of path segments
1106          *                        in the path
1107          * @see #WIND_EVEN_ODD
1108          * @see #WIND_NON_ZERO
1109          * @since 1.6
1110          */
1111         public Double(int rule, int initialCapacity) {
1112             super(rule, initialCapacity);
1113             doubleCoords = new double[initialCapacity * 2];
1114         }
1115 
1116         /**
1117          * Constructs a new double precision {@code Path2D} object
1118          * from an arbitrary {@link Shape} object.
1119          * All of the initial geometry and the winding rule for this path are
1120          * taken from the specified {@code Shape} object.
1121          *
1122          * @param s the specified {@code Shape} object
1123          * @since 1.6
1124          */
1125         public Double(Shape s) {
1126             this(s, null);
1127         }
1128 
1129         /**
1130          * Constructs a new double precision {@code Path2D} object
1131          * from an arbitrary {@link Shape} object, transformed by an
1132          * {@link AffineTransform} object.
1133          * All of the initial geometry and the winding rule for this path are
1134          * taken from the specified {@code Shape} object and transformed
1135          * by the specified {@code AffineTransform} object.
1136          *
1137          * @param s the specified {@code Shape} object
1138          * @param at the specified {@code AffineTransform} object
1139          * @since 1.6
1140          */
1141         public Double(Shape s, AffineTransform at) {
1142             if (s instanceof Path2D) {
1143                 Path2D p2d = (Path2D) s;
1144                 setWindingRule(p2d.windingRule);
1145                 this.numTypes = p2d.numTypes;
1146                 // trim arrays:
1147                 this.pointTypes = Arrays.copyOf(p2d.pointTypes, p2d.numTypes);
1148                 this.numCoords = p2d.numCoords;
1149                 this.doubleCoords = p2d.cloneCoordsDouble(at);
1150             } else {
1151                 PathIterator pi = s.getPathIterator(at);
1152                 setWindingRule(pi.getWindingRule());
1153                 this.pointTypes = new byte[INIT_SIZE];
1154                 this.doubleCoords = new double[INIT_SIZE * 2];
1155                 append(pi, false);
1156             }
1157         }
1158 
1159         @Override
1160         public final Path2D trimToSize() {
1161             // trim arrays:
1162             if (numTypes < pointTypes.length) {
1163                 this.pointTypes = Arrays.copyOf(pointTypes, numTypes);
1164             }
1165             if (numCoords < doubleCoords.length) {
1166                 this.doubleCoords = Arrays.copyOf(doubleCoords, numCoords);
1167             }
1168             return this;
1169         }
1170 
1171         @Override
1172         float[] cloneCoordsFloat(AffineTransform at) {
1173             // trim arrays:
1174             float ret[] = new float[numCoords];
1175             if (at == null) {
1176                 for (int i = 0; i < numCoords; i++) {
1177                     ret[i] = (float) doubleCoords[i];
1178                 }
1179             } else {
1180                 at.transform(doubleCoords, 0, ret, 0, numCoords / 2);
1181             }
1182             return ret;
1183         }
1184 
1185         @Override
1186         double[] cloneCoordsDouble(AffineTransform at) {
1187             // trim arrays:
1188             double ret[];
1189             if (at == null) {
1190                 ret = Arrays.copyOf(doubleCoords, numCoords);
1191             } else {
1192                 ret = new double[numCoords];
1193                 at.transform(doubleCoords, 0, ret, 0, numCoords / 2);
1194             }
1195             return ret;
1196         }
1197 
1198         void append(float x, float y) {
1199             doubleCoords[numCoords++] = x;
1200             doubleCoords[numCoords++] = y;
1201         }
1202 
1203         void append(double x, double y) {
1204             doubleCoords[numCoords++] = x;
1205             doubleCoords[numCoords++] = y;
1206         }
1207 
1208         Point2D getPoint(int coordindex) {
1209             return new Point2D.Double(doubleCoords[coordindex],
1210                                       doubleCoords[coordindex+1]);
1211         }
1212 
1213         @Override
1214         void needRoom(boolean needMove, int newCoords) {
1215             if ((numTypes == 0) && needMove) {
1216                 throw new IllegalPathStateException("missing initial moveto "+
1217                                                     "in path definition");
1218             }
1219             if (numTypes >= pointTypes.length) {
1220                 pointTypes = expandPointTypes(pointTypes, 1);
1221             }
1222             if (numCoords > (doubleCoords.length - newCoords)) {
1223                 doubleCoords = expandCoords(doubleCoords, newCoords);
1224             }
1225         }
1226 
1227         static double[] expandCoords(double[] oldCoords, int needed) {
1228             final int oldSize = oldCoords.length;
1229             final int newSizeMin = oldSize + needed;
1230             if (newSizeMin < oldSize) {
1231                 // hard overflow failure - we can't even accommodate
1232                 // new items without overflowing
1233                 throw new ArrayIndexOutOfBoundsException(
1234                               "coords exceeds maximum capacity !");
1235             }
1236             // growth algorithm computation
1237             int grow = oldSize;
1238             if (grow > EXPAND_MAX_COORDS) {
1239                 grow = Math.max(EXPAND_MAX_COORDS, oldSize >> 3); // 1/8th min
1240             } else if (grow < EXPAND_MIN) {
1241                 grow = EXPAND_MIN;
1242             }
1243             assert grow > needed;
1244 
1245             int newSize = oldSize + grow;
1246             if (newSize < newSizeMin) {
1247                 // overflow in growth algorithm computation
1248                 newSize = Integer.MAX_VALUE;
1249             }
1250             while (true) {
1251                 try {
1252                     // try allocating the larger array
1253                     return Arrays.copyOf(oldCoords, newSize);
1254                 } catch (OutOfMemoryError oome) {
1255                     if (newSize == newSizeMin) {
1256                         throw oome;
1257                     }
1258                 }
1259                 newSize = newSizeMin + (newSize - newSizeMin) / 2;
1260             }
1261         }
1262 
1263         /**
1264          * {@inheritDoc}
1265          * @since 1.6
1266          */
1267         public final synchronized void moveTo(double x, double y) {
1268             if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
1269                 doubleCoords[numCoords-2] = x;
1270                 doubleCoords[numCoords-1] = y;
1271             } else {
1272                 needRoom(false, 2);
1273                 pointTypes[numTypes++] = SEG_MOVETO;
1274                 doubleCoords[numCoords++] = x;
1275                 doubleCoords[numCoords++] = y;
1276             }
1277         }
1278 
1279         /**
1280          * {@inheritDoc}
1281          * @since 1.6
1282          */
1283         public final synchronized void lineTo(double x, double y) {
1284             needRoom(true, 2);
1285             pointTypes[numTypes++] = SEG_LINETO;
1286             doubleCoords[numCoords++] = x;
1287             doubleCoords[numCoords++] = y;
1288         }
1289 
1290         /**
1291          * {@inheritDoc}
1292          * @since 1.6
1293          */
1294         public final synchronized void quadTo(double x1, double y1,
1295                                               double x2, double y2)
1296         {
1297             needRoom(true, 4);
1298             pointTypes[numTypes++] = SEG_QUADTO;
1299             doubleCoords[numCoords++] = x1;
1300             doubleCoords[numCoords++] = y1;
1301             doubleCoords[numCoords++] = x2;
1302             doubleCoords[numCoords++] = y2;
1303         }
1304 
1305         /**
1306          * {@inheritDoc}
1307          * @since 1.6
1308          */
1309         public final synchronized void curveTo(double x1, double y1,
1310                                                double x2, double y2,
1311                                                double x3, double y3)
1312         {
1313             needRoom(true, 6);
1314             pointTypes[numTypes++] = SEG_CUBICTO;
1315             doubleCoords[numCoords++] = x1;
1316             doubleCoords[numCoords++] = y1;
1317             doubleCoords[numCoords++] = x2;
1318             doubleCoords[numCoords++] = y2;
1319             doubleCoords[numCoords++] = x3;
1320             doubleCoords[numCoords++] = y3;
1321         }
1322 
1323         int pointCrossings(double px, double py) {
1324             if (numTypes == 0) {
1325                 return 0;
1326             }
1327             double movx, movy, curx, cury, endx, endy;
1328             double coords[] = doubleCoords;
1329             curx = movx = coords[0];
1330             cury = movy = coords[1];
1331             int crossings = 0;
1332             int ci = 2;
1333             for (int i = 1; i < numTypes; i++) {
1334                 switch (pointTypes[i]) {
1335                 case PathIterator.SEG_MOVETO:
1336                     if (cury != movy) {
1337                         crossings +=
1338                             Curve.pointCrossingsForLine(px, py,
1339                                                         curx, cury,
1340                                                         movx, movy);
1341                     }
1342                     movx = curx = coords[ci++];
1343                     movy = cury = coords[ci++];
1344                     break;
1345                 case PathIterator.SEG_LINETO:
1346                     crossings +=
1347                         Curve.pointCrossingsForLine(px, py,
1348                                                     curx, cury,
1349                                                     endx = coords[ci++],
1350                                                     endy = coords[ci++]);
1351                     curx = endx;
1352                     cury = endy;
1353                     break;
1354                 case PathIterator.SEG_QUADTO:
1355                     crossings +=
1356                         Curve.pointCrossingsForQuad(px, py,
1357                                                     curx, cury,
1358                                                     coords[ci++],
1359                                                     coords[ci++],
1360                                                     endx = coords[ci++],
1361                                                     endy = coords[ci++],
1362                                                     0);
1363                     curx = endx;
1364                     cury = endy;
1365                     break;
1366             case PathIterator.SEG_CUBICTO:
1367                     crossings +=
1368                         Curve.pointCrossingsForCubic(px, py,
1369                                                      curx, cury,
1370                                                      coords[ci++],
1371                                                      coords[ci++],
1372                                                      coords[ci++],
1373                                                      coords[ci++],
1374                                                      endx = coords[ci++],
1375                                                      endy = coords[ci++],
1376                                                      0);
1377                     curx = endx;
1378                     cury = endy;
1379                     break;
1380                 case PathIterator.SEG_CLOSE:
1381                     if (cury != movy) {
1382                         crossings +=
1383                             Curve.pointCrossingsForLine(px, py,
1384                                                         curx, cury,
1385                                                         movx, movy);
1386                     }
1387                     curx = movx;
1388                     cury = movy;
1389                     break;
1390                 }
1391             }
1392             if (cury != movy) {
1393                 crossings +=
1394                     Curve.pointCrossingsForLine(px, py,
1395                                                 curx, cury,
1396                                                 movx, movy);
1397             }
1398             return crossings;
1399         }
1400 
1401         int rectCrossings(double rxmin, double rymin,
1402                           double rxmax, double rymax)
1403         {
1404             if (numTypes == 0) {
1405                 return 0;
1406             }
1407             double coords[] = doubleCoords;
1408             double curx, cury, movx, movy, endx, endy;
1409             curx = movx = coords[0];
1410             cury = movy = coords[1];
1411             int crossings = 0;
1412             int ci = 2;
1413             for (int i = 1;
1414                  crossings != Curve.RECT_INTERSECTS && i < numTypes;
1415                  i++)
1416             {
1417                 switch (pointTypes[i]) {
1418                 case PathIterator.SEG_MOVETO:
1419                     if (curx != movx || cury != movy) {
1420                         crossings =
1421                             Curve.rectCrossingsForLine(crossings,
1422                                                        rxmin, rymin,
1423                                                        rxmax, rymax,
1424                                                        curx, cury,
1425                                                        movx, movy);
1426                     }
1427                     // Count should always be a multiple of 2 here.
1428                     // assert((crossings & 1) != 0);
1429                     movx = curx = coords[ci++];
1430                     movy = cury = coords[ci++];
1431                     break;
1432                 case PathIterator.SEG_LINETO:
1433                     endx = coords[ci++];
1434                     endy = coords[ci++];
1435                     crossings =
1436                         Curve.rectCrossingsForLine(crossings,
1437                                                    rxmin, rymin,
1438                                                    rxmax, rymax,
1439                                                    curx, cury,
1440                                                    endx, endy);
1441                     curx = endx;
1442                     cury = endy;
1443                     break;
1444                 case PathIterator.SEG_QUADTO:
1445                     crossings =
1446                         Curve.rectCrossingsForQuad(crossings,
1447                                                    rxmin, rymin,
1448                                                    rxmax, rymax,
1449                                                    curx, cury,
1450                                                    coords[ci++],
1451                                                    coords[ci++],
1452                                                    endx = coords[ci++],
1453                                                    endy = coords[ci++],
1454                                                    0);
1455                     curx = endx;
1456                     cury = endy;
1457                     break;
1458                 case PathIterator.SEG_CUBICTO:
1459                     crossings =
1460                         Curve.rectCrossingsForCubic(crossings,
1461                                                     rxmin, rymin,
1462                                                     rxmax, rymax,
1463                                                     curx, cury,
1464                                                     coords[ci++],
1465                                                     coords[ci++],
1466                                                     coords[ci++],
1467                                                     coords[ci++],
1468                                                     endx = coords[ci++],
1469                                                     endy = coords[ci++],
1470                                                     0);
1471                     curx = endx;
1472                     cury = endy;
1473                     break;
1474                 case PathIterator.SEG_CLOSE:
1475                     if (curx != movx || cury != movy) {
1476                         crossings =
1477                             Curve.rectCrossingsForLine(crossings,
1478                                                        rxmin, rymin,
1479                                                        rxmax, rymax,
1480                                                        curx, cury,
1481                                                        movx, movy);
1482                     }
1483                     curx = movx;
1484                     cury = movy;
1485                     // Count should always be a multiple of 2 here.
1486                     // assert((crossings & 1) != 0);
1487                     break;
1488                 }
1489             }
1490             if (crossings != Curve.RECT_INTERSECTS &&
1491                 (curx != movx || cury != movy))
1492             {
1493                 crossings =
1494                     Curve.rectCrossingsForLine(crossings,
1495                                                rxmin, rymin,
1496                                                rxmax, rymax,
1497                                                curx, cury,
1498                                                movx, movy);
1499             }
1500             // Count should always be a multiple of 2 here.
1501             // assert((crossings & 1) != 0);
1502             return crossings;
1503         }
1504 
1505         /**
1506          * {@inheritDoc}
1507          * @since 1.6
1508          */
1509         public final void append(PathIterator pi, boolean connect) {
1510             double coords[] = new double[6];
1511             while (!pi.isDone()) {
1512                 switch (pi.currentSegment(coords)) {
1513                 case SEG_MOVETO:
1514                     if (!connect || numTypes < 1 || numCoords < 1) {
1515                         moveTo(coords[0], coords[1]);
1516                         break;
1517                     }
1518                     if (pointTypes[numTypes - 1] != SEG_CLOSE &&
1519                         doubleCoords[numCoords-2] == coords[0] &&
1520                         doubleCoords[numCoords-1] == coords[1])
1521                     {
1522                         // Collapse out initial moveto/lineto
1523                         break;
1524                     }
1525                     lineTo(coords[0], coords[1]);
1526                     break;
1527                 case SEG_LINETO:
1528                     lineTo(coords[0], coords[1]);
1529                     break;
1530                 case SEG_QUADTO:
1531                     quadTo(coords[0], coords[1],
1532                            coords[2], coords[3]);
1533                     break;
1534                 case SEG_CUBICTO:
1535                     curveTo(coords[0], coords[1],
1536                             coords[2], coords[3],
1537                             coords[4], coords[5]);
1538                     break;
1539                 case SEG_CLOSE:
1540                     closePath();
1541                     break;
1542                 }
1543                 pi.next();
1544                 connect = false;
1545             }
1546         }
1547 
1548         /**
1549          * {@inheritDoc}
1550          * @since 1.6
1551          */
1552         public final void transform(AffineTransform at) {
1553             at.transform(doubleCoords, 0, doubleCoords, 0, numCoords / 2);
1554         }
1555 
1556         /**
1557          * {@inheritDoc}
1558          * @since 1.6
1559          */
1560         public final synchronized Rectangle2D getBounds2D() {
1561             double x1, y1, x2, y2;
1562             int i = numCoords;
1563             if (i > 0) {
1564                 y1 = y2 = doubleCoords[--i];
1565                 x1 = x2 = doubleCoords[--i];
1566                 while (i > 0) {
1567                     double y = doubleCoords[--i];
1568                     double x = doubleCoords[--i];
1569                     if (x < x1) x1 = x;
1570                     if (y < y1) y1 = y;
1571                     if (x > x2) x2 = x;
1572                     if (y > y2) y2 = y;
1573                 }
1574             } else {
1575                 x1 = y1 = x2 = y2 = 0.0;
1576             }
1577             return new Rectangle2D.Double(x1, y1, x2 - x1, y2 - y1);
1578         }
1579 
1580         /**
1581          * {@inheritDoc}
1582          * <p>
1583          * The iterator for this class is not multi-threaded safe,
1584          * which means that the {@code Path2D} class does not
1585          * guarantee that modifications to the geometry of this
1586          * {@code Path2D} object do not affect any iterations of
1587          * that geometry that are already in process.
1588          *
1589          * @param at an {@code AffineTransform}
1590          * @return a new {@code PathIterator} that iterates along the boundary
1591          *         of this {@code Shape} and provides access to the geometry
1592          *         of this {@code Shape}'s outline
1593          * @since 1.6
1594          */
1595         public final PathIterator getPathIterator(AffineTransform at) {
1596             if (at == null) {
1597                 return new CopyIterator(this);
1598             } else {
1599                 return new TxIterator(this, at);
1600             }
1601         }
1602 
1603         /**
1604          * Creates a new object of the same class as this object.
1605          *
1606          * @return     a clone of this instance.
1607          * @exception  OutOfMemoryError    if there is not enough memory.
1608          * @see        java.lang.Cloneable
1609          * @since      1.6
1610          */
1611         public final Object clone() {
1612             // Note: It would be nice to have this return Path2D
1613             // but one of our subclasses (GeneralPath) needs to
1614             // offer "public Object clone()" for backwards
1615             // compatibility so we cannot restrict it further.
1616             // REMIND: Can we do both somehow?
1617             return new Path2D.Double(this);
1618         }
1619 
1620         /*
1621          * JDK 1.6 serialVersionUID
1622          */
1623         private static final long serialVersionUID = 1826762518450014216L;
1624 
1625         /**
1626          * Writes the default serializable fields to the
1627          * {@code ObjectOutputStream} followed by an explicit
1628          * serialization of the path segments stored in this
1629          * path.
1630          *
1631          * @serialData
1632          * <a name="Path2DSerialData"><!-- --></a>
1633          * <ol>
1634          * <li>The default serializable fields.
1635          * There are no default serializable fields as of 1.6.
1636          * <li>followed by
1637          * a byte indicating the storage type of the original object
1638          * as a hint (SERIAL_STORAGE_DBL_ARRAY)
1639          * <li>followed by
1640          * an integer indicating the number of path segments to follow (NP)
1641          * or -1 to indicate an unknown number of path segments follows
1642          * <li>followed by
1643          * an integer indicating the total number of coordinates to follow (NC)
1644          * or -1 to indicate an unknown number of coordinates follows
1645          * (NC should always be even since coordinates always appear in pairs
1646          *  representing an x,y pair)
1647          * <li>followed by
1648          * a byte indicating the winding rule
1649          * ({@link #WIND_EVEN_ODD WIND_EVEN_ODD} or
1650          *  {@link #WIND_NON_ZERO WIND_NON_ZERO})
1651          * <li>followed by
1652          * {@code NP} (or unlimited if {@code NP < 0}) sets of values consisting of
1653          * a single byte indicating a path segment type
1654          * followed by one or more pairs of float or double
1655          * values representing the coordinates of the path segment
1656          * <li>followed by
1657          * a byte indicating the end of the path (SERIAL_PATH_END).
1658          * </ol>
1659          * <p>
1660          * The following byte value constants are used in the serialized form
1661          * of {@code Path2D} objects:
1662          * <table>
1663          * <tr>
1664          * <th>Constant Name</th>
1665          * <th>Byte Value</th>
1666          * <th>Followed by</th>
1667          * <th>Description</th>
1668          * </tr>
1669          * <tr>
1670          * <td>{@code SERIAL_STORAGE_FLT_ARRAY}</td>
1671          * <td>0x30</td>
1672          * <td></td>
1673          * <td>A hint that the original {@code Path2D} object stored
1674          * the coordinates in a Java array of floats.</td>
1675          * </tr>
1676          * <tr>
1677          * <td>{@code SERIAL_STORAGE_DBL_ARRAY}</td>
1678          * <td>0x31</td>
1679          * <td></td>
1680          * <td>A hint that the original {@code Path2D} object stored
1681          * the coordinates in a Java array of doubles.</td>
1682          * </tr>
1683          * <tr>
1684          * <td>{@code SERIAL_SEG_FLT_MOVETO}</td>
1685          * <td>0x40</td>
1686          * <td>2 floats</td>
1687          * <td>A {@link #moveTo moveTo} path segment follows.</td>
1688          * </tr>
1689          * <tr>
1690          * <td>{@code SERIAL_SEG_FLT_LINETO}</td>
1691          * <td>0x41</td>
1692          * <td>2 floats</td>
1693          * <td>A {@link #lineTo lineTo} path segment follows.</td>
1694          * </tr>
1695          * <tr>
1696          * <td>{@code SERIAL_SEG_FLT_QUADTO}</td>
1697          * <td>0x42</td>
1698          * <td>4 floats</td>
1699          * <td>A {@link #quadTo quadTo} path segment follows.</td>
1700          * </tr>
1701          * <tr>
1702          * <td>{@code SERIAL_SEG_FLT_CUBICTO}</td>
1703          * <td>0x43</td>
1704          * <td>6 floats</td>
1705          * <td>A {@link #curveTo curveTo} path segment follows.</td>
1706          * </tr>
1707          * <tr>
1708          * <td>{@code SERIAL_SEG_DBL_MOVETO}</td>
1709          * <td>0x50</td>
1710          * <td>2 doubles</td>
1711          * <td>A {@link #moveTo moveTo} path segment follows.</td>
1712          * </tr>
1713          * <tr>
1714          * <td>{@code SERIAL_SEG_DBL_LINETO}</td>
1715          * <td>0x51</td>
1716          * <td>2 doubles</td>
1717          * <td>A {@link #lineTo lineTo} path segment follows.</td>
1718          * </tr>
1719          * <tr>
1720          * <td>{@code SERIAL_SEG_DBL_QUADTO}</td>
1721          * <td>0x52</td>
1722          * <td>4 doubles</td>
1723          * <td>A {@link #curveTo curveTo} path segment follows.</td>
1724          * </tr>
1725          * <tr>
1726          * <td>{@code SERIAL_SEG_DBL_CUBICTO}</td>
1727          * <td>0x53</td>
1728          * <td>6 doubles</td>
1729          * <td>A {@link #curveTo curveTo} path segment follows.</td>
1730          * </tr>
1731          * <tr>
1732          * <td>{@code SERIAL_SEG_CLOSE}</td>
1733          * <td>0x60</td>
1734          * <td></td>
1735          * <td>A {@link #closePath closePath} path segment.</td>
1736          * </tr>
1737          * <tr>
1738          * <td>{@code SERIAL_PATH_END}</td>
1739          * <td>0x61</td>
1740          * <td></td>
1741          * <td>There are no more path segments following.</td>
1742          * </table>
1743          *
1744          * @since 1.6
1745          */
1746         private void writeObject(java.io.ObjectOutputStream s)
1747             throws java.io.IOException
1748         {
1749             super.writeObject(s, true);
1750         }
1751 
1752         /**
1753          * Reads the default serializable fields from the
1754          * {@code ObjectInputStream} followed by an explicit
1755          * serialization of the path segments stored in this
1756          * path.
1757          * <p>
1758          * There are no default serializable fields as of 1.6.
1759          * <p>
1760          * The serial data for this object is described in the
1761          * writeObject method.
1762          *
1763          * @since 1.6
1764          */
1765         private void readObject(java.io.ObjectInputStream s)
1766             throws java.lang.ClassNotFoundException, java.io.IOException
1767         {
1768             super.readObject(s, true);
1769         }
1770 
1771         static class CopyIterator extends Path2D.Iterator {
1772             double doubleCoords[];
1773 
1774             CopyIterator(Path2D.Double p2dd) {
1775                 super(p2dd);
1776                 this.doubleCoords = p2dd.doubleCoords;
1777             }
1778 
1779             public int currentSegment(float[] coords) {
1780                 int type = path.pointTypes[typeIdx];
1781                 int numCoords = curvecoords[type];
1782                 if (numCoords > 0) {
1783                     for (int i = 0; i < numCoords; i++) {
1784                         coords[i] = (float) doubleCoords[pointIdx + i];
1785                     }
1786                 }
1787                 return type;
1788             }
1789 
1790             public int currentSegment(double[] coords) {
1791                 int type = path.pointTypes[typeIdx];
1792                 int numCoords = curvecoords[type];
1793                 if (numCoords > 0) {
1794                     System.arraycopy(doubleCoords, pointIdx,
1795                                      coords, 0, numCoords);
1796                 }
1797                 return type;
1798             }
1799         }
1800 
1801         static class TxIterator extends Path2D.Iterator {
1802             double doubleCoords[];
1803             AffineTransform affine;
1804 
1805             TxIterator(Path2D.Double p2dd, AffineTransform at) {
1806                 super(p2dd);
1807                 this.doubleCoords = p2dd.doubleCoords;
1808                 this.affine = at;
1809             }
1810 
1811             public int currentSegment(float[] coords) {
1812                 int type = path.pointTypes[typeIdx];
1813                 int numCoords = curvecoords[type];
1814                 if (numCoords > 0) {
1815                     affine.transform(doubleCoords, pointIdx,
1816                                      coords, 0, numCoords / 2);
1817                 }
1818                 return type;
1819             }
1820 
1821             public int currentSegment(double[] coords) {
1822                 int type = path.pointTypes[typeIdx];
1823                 int numCoords = curvecoords[type];
1824                 if (numCoords > 0) {
1825                     affine.transform(doubleCoords, pointIdx,
1826                                      coords, 0, numCoords / 2);
1827                 }
1828                 return type;
1829             }
1830         }
1831     }
1832 
1833     /**
1834      * Adds a point to the path by moving to the specified
1835      * coordinates specified in double precision.
1836      *
1837      * @param x the specified X coordinate
1838      * @param y the specified Y coordinate
1839      * @since 1.6
1840      */
1841     public abstract void moveTo(double x, double y);
1842 
1843     /**
1844      * Adds a point to the path by drawing a straight line from the
1845      * current coordinates to the new specified coordinates
1846      * specified in double precision.
1847      *
1848      * @param x the specified X coordinate
1849      * @param y the specified Y coordinate
1850      * @since 1.6
1851      */
1852     public abstract void lineTo(double x, double y);
1853 
1854     /**
1855      * Adds a curved segment, defined by two new points, to the path by
1856      * drawing a Quadratic curve that intersects both the current
1857      * coordinates and the specified coordinates {@code (x2,y2)},
1858      * using the specified point {@code (x1,y1)} as a quadratic
1859      * parametric control point.
1860      * All coordinates are specified in double precision.
1861      *
1862      * @param x1 the X coordinate of the quadratic control point
1863      * @param y1 the Y coordinate of the quadratic control point
1864      * @param x2 the X coordinate of the final end point
1865      * @param y2 the Y coordinate of the final end point
1866      * @since 1.6
1867      */
1868     public abstract void quadTo(double x1, double y1,
1869                                 double x2, double y2);
1870 
1871     /**
1872      * Adds a curved segment, defined by three new points, to the path by
1873      * drawing a B&eacute;zier curve that intersects both the current
1874      * coordinates and the specified coordinates {@code (x3,y3)},
1875      * using the specified points {@code (x1,y1)} and {@code (x2,y2)} as
1876      * B&eacute;zier control points.
1877      * All coordinates are specified in double precision.
1878      *
1879      * @param x1 the X coordinate of the first B&eacute;zier control point
1880      * @param y1 the Y coordinate of the first B&eacute;zier control point
1881      * @param x2 the X coordinate of the second B&eacute;zier control point
1882      * @param y2 the Y coordinate of the second B&eacute;zier control point
1883      * @param x3 the X coordinate of the final end point
1884      * @param y3 the Y coordinate of the final end point
1885      * @since 1.6
1886      */
1887     public abstract void curveTo(double x1, double y1,
1888                                  double x2, double y2,
1889                                  double x3, double y3);
1890 
1891     /**
1892      * Closes the current subpath by drawing a straight line back to
1893      * the coordinates of the last {@code moveTo}.  If the path is already
1894      * closed then this method has no effect.
1895      *
1896      * @since 1.6
1897      */
1898     public final synchronized void closePath() {
1899         if (numTypes == 0 || pointTypes[numTypes - 1] != SEG_CLOSE) {
1900             needRoom(true, 0);
1901             pointTypes[numTypes++] = SEG_CLOSE;
1902         }
1903     }
1904 
1905     /**
1906      * Appends the geometry of the specified {@code Shape} object to the
1907      * path, possibly connecting the new geometry to the existing path
1908      * segments with a line segment.
1909      * If the {@code connect} parameter is {@code true} and the
1910      * path is not empty then any initial {@code moveTo} in the
1911      * geometry of the appended {@code Shape}
1912      * is turned into a {@code lineTo} segment.
1913      * If the destination coordinates of such a connecting {@code lineTo}
1914      * segment match the ending coordinates of a currently open
1915      * subpath then the segment is omitted as superfluous.
1916      * The winding rule of the specified {@code Shape} is ignored
1917      * and the appended geometry is governed by the winding
1918      * rule specified for this path.
1919      *
1920      * @param s the {@code Shape} whose geometry is appended
1921      *          to this path
1922      * @param connect a boolean to control whether or not to turn an initial
1923      *                {@code moveTo} segment into a {@code lineTo} segment
1924      *                to connect the new geometry to the existing path
1925      * @since 1.6
1926      */
1927     public final void append(Shape s, boolean connect) {
1928         append(s.getPathIterator(null), connect);
1929     }
1930 
1931     /**
1932      * Appends the geometry of the specified
1933      * {@link PathIterator} object
1934      * to the path, possibly connecting the new geometry to the existing
1935      * path segments with a line segment.
1936      * If the {@code connect} parameter is {@code true} and the
1937      * path is not empty then any initial {@code moveTo} in the
1938      * geometry of the appended {@code Shape} is turned into a
1939      * {@code lineTo} segment.
1940      * If the destination coordinates of such a connecting {@code lineTo}
1941      * segment match the ending coordinates of a currently open
1942      * subpath then the segment is omitted as superfluous.
1943      * The winding rule of the specified {@code Shape} is ignored
1944      * and the appended geometry is governed by the winding
1945      * rule specified for this path.
1946      *
1947      * @param pi the {@code PathIterator} whose geometry is appended to
1948      *           this path
1949      * @param connect a boolean to control whether or not to turn an initial
1950      *                {@code moveTo} segment into a {@code lineTo} segment
1951      *                to connect the new geometry to the existing path
1952      * @since 1.6
1953      */
1954     public abstract void append(PathIterator pi, boolean connect);
1955 
1956     /**
1957      * Returns the fill style winding rule.
1958      *
1959      * @return an integer representing the current winding rule.
1960      * @see #WIND_EVEN_ODD
1961      * @see #WIND_NON_ZERO
1962      * @see #setWindingRule
1963      * @since 1.6
1964      */
1965     public final synchronized int getWindingRule() {
1966         return windingRule;
1967     }
1968 
1969     /**
1970      * Sets the winding rule for this path to the specified value.
1971      *
1972      * @param rule an integer representing the specified
1973      *             winding rule
1974      * @exception IllegalArgumentException if
1975      *          {@code rule} is not either
1976      *          {@link #WIND_EVEN_ODD} or
1977      *          {@link #WIND_NON_ZERO}
1978      * @see #getWindingRule
1979      * @since 1.6
1980      */
1981     public final void setWindingRule(int rule) {
1982         if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {
1983             throw new IllegalArgumentException("winding rule must be "+
1984                                                "WIND_EVEN_ODD or "+
1985                                                "WIND_NON_ZERO");
1986         }
1987         windingRule = rule;
1988     }
1989 
1990     /**
1991      * Returns the coordinates most recently added to the end of the path
1992      * as a {@link Point2D} object.
1993      *
1994      * @return a {@code Point2D} object containing the ending coordinates of
1995      *         the path or {@code null} if there are no points in the path.
1996      * @since 1.6
1997      */
1998     public final synchronized Point2D getCurrentPoint() {
1999         int index = numCoords;
2000         if (numTypes < 1 || index < 1) {
2001             return null;
2002         }
2003         if (pointTypes[numTypes - 1] == SEG_CLOSE) {
2004         loop:
2005             for (int i = numTypes - 2; i > 0; i--) {
2006                 switch (pointTypes[i]) {
2007                 case SEG_MOVETO:
2008                     break loop;
2009                 case SEG_LINETO:
2010                     index -= 2;
2011                     break;
2012                 case SEG_QUADTO:
2013                     index -= 4;
2014                     break;
2015                 case SEG_CUBICTO:
2016                     index -= 6;
2017                     break;
2018                 case SEG_CLOSE:
2019                     break;
2020                 }
2021             }
2022         }
2023         return getPoint(index - 2);
2024     }
2025 
2026     /**
2027      * Resets the path to empty.  The append position is set back to the
2028      * beginning of the path and all coordinates and point types are
2029      * forgotten.
2030      *
2031      * @since 1.6
2032      */
2033     public final synchronized void reset() {
2034         numTypes = numCoords = 0;
2035     }
2036 
2037     /**
2038      * Transforms the geometry of this path using the specified
2039      * {@link AffineTransform}.
2040      * The geometry is transformed in place, which permanently changes the
2041      * boundary defined by this object.
2042      *
2043      * @param at the {@code AffineTransform} used to transform the area
2044      * @since 1.6
2045      */
2046     public abstract void transform(AffineTransform at);
2047 
2048     /**
2049      * Returns a new {@code Shape} representing a transformed version
2050      * of this {@code Path2D}.
2051      * Note that the exact type and coordinate precision of the return
2052      * value is not specified for this method.
2053      * The method will return a Shape that contains no less precision
2054      * for the transformed geometry than this {@code Path2D} currently
2055      * maintains, but it may contain no more precision either.
2056      * If the tradeoff of precision vs. storage size in the result is
2057      * important then the convenience constructors in the
2058      * {@link Path2D.Float#Float(Shape, AffineTransform) Path2D.Float}
2059      * and
2060      * {@link Path2D.Double#Double(Shape, AffineTransform) Path2D.Double}
2061      * subclasses should be used to make the choice explicit.
2062      *
2063      * @param at the {@code AffineTransform} used to transform a
2064      *           new {@code Shape}.
2065      * @return a new {@code Shape}, transformed with the specified
2066      *         {@code AffineTransform}.
2067      * @since 1.6
2068      */
2069     public final synchronized Shape createTransformedShape(AffineTransform at) {
2070         Path2D p2d = (Path2D) clone();
2071         if (at != null) {
2072             p2d.transform(at);
2073         }
2074         return p2d;
2075     }
2076 
2077     /**
2078      * {@inheritDoc}
2079      * @since 1.6
2080      */
2081     public final Rectangle getBounds() {
2082         return getBounds2D().getBounds();
2083     }
2084 
2085     /**
2086      * Tests if the specified coordinates are inside the closed
2087      * boundary of the specified {@link PathIterator}.
2088      * <p>
2089      * This method provides a basic facility for implementors of
2090      * the {@link Shape} interface to implement support for the
2091      * {@link Shape#contains(double, double)} method.
2092      *
2093      * @param pi the specified {@code PathIterator}
2094      * @param x the specified X coordinate
2095      * @param y the specified Y coordinate
2096      * @return {@code true} if the specified coordinates are inside the
2097      *         specified {@code PathIterator}; {@code false} otherwise
2098      * @since 1.6
2099      */
2100     public static boolean contains(PathIterator pi, double x, double y) {
2101         if (x * 0.0 + y * 0.0 == 0.0) {
2102             /* N * 0.0 is 0.0 only if N is finite.
2103              * Here we know that both x and y are finite.
2104              */
2105             int mask = (pi.getWindingRule() == WIND_NON_ZERO ? -1 : 1);
2106             int cross = Curve.pointCrossingsForPath(pi, x, y);
2107             return ((cross & mask) != 0);
2108         } else {
2109             /* Either x or y was infinite or NaN.
2110              * A NaN always produces a negative response to any test
2111              * and Infinity values cannot be "inside" any path so
2112              * they should return false as well.
2113              */
2114             return false;
2115         }
2116     }
2117 
2118     /**
2119      * Tests if the specified {@link Point2D} is inside the closed
2120      * boundary of the specified {@link PathIterator}.
2121      * <p>
2122      * This method provides a basic facility for implementors of
2123      * the {@link Shape} interface to implement support for the
2124      * {@link Shape#contains(Point2D)} method.
2125      *
2126      * @param pi the specified {@code PathIterator}
2127      * @param p the specified {@code Point2D}
2128      * @return {@code true} if the specified coordinates are inside the
2129      *         specified {@code PathIterator}; {@code false} otherwise
2130      * @since 1.6
2131      */
2132     public static boolean contains(PathIterator pi, Point2D p) {
2133         return contains(pi, p.getX(), p.getY());
2134     }
2135 
2136     /**
2137      * {@inheritDoc}
2138      * @since 1.6
2139      */
2140     public final boolean contains(double x, double y) {
2141         if (x * 0.0 + y * 0.0 == 0.0) {
2142             /* N * 0.0 is 0.0 only if N is finite.
2143              * Here we know that both x and y are finite.
2144              */
2145             if (numTypes < 2) {
2146                 return false;
2147             }
2148             int mask = (windingRule == WIND_NON_ZERO ? -1 : 1);
2149             return ((pointCrossings(x, y) & mask) != 0);
2150         } else {
2151             /* Either x or y was infinite or NaN.
2152              * A NaN always produces a negative response to any test
2153              * and Infinity values cannot be "inside" any path so
2154              * they should return false as well.
2155              */
2156             return false;
2157         }
2158     }
2159 
2160     /**
2161      * {@inheritDoc}
2162      * @since 1.6
2163      */
2164     public final boolean contains(Point2D p) {
2165         return contains(p.getX(), p.getY());
2166     }
2167 
2168     /**
2169      * Tests if the specified rectangular area is entirely inside the
2170      * closed boundary of the specified {@link PathIterator}.
2171      * <p>
2172      * This method provides a basic facility for implementors of
2173      * the {@link Shape} interface to implement support for the
2174      * {@link Shape#contains(double, double, double, double)} method.
2175      * <p>
2176      * This method object may conservatively return false in
2177      * cases where the specified rectangular area intersects a
2178      * segment of the path, but that segment does not represent a
2179      * boundary between the interior and exterior of the path.
2180      * Such segments could lie entirely within the interior of the
2181      * path if they are part of a path with a {@link #WIND_NON_ZERO}
2182      * winding rule or if the segments are retraced in the reverse
2183      * direction such that the two sets of segments cancel each
2184      * other out without any exterior area falling between them.
2185      * To determine whether segments represent true boundaries of
2186      * the interior of the path would require extensive calculations
2187      * involving all of the segments of the path and the winding
2188      * rule and are thus beyond the scope of this implementation.
2189      *
2190      * @param pi the specified {@code PathIterator}
2191      * @param x the specified X coordinate
2192      * @param y the specified Y coordinate
2193      * @param w the width of the specified rectangular area
2194      * @param h the height of the specified rectangular area
2195      * @return {@code true} if the specified {@code PathIterator} contains
2196      *         the specified rectangular area; {@code false} otherwise.
2197      * @since 1.6
2198      */
2199     public static boolean contains(PathIterator pi,
2200                                    double x, double y, double w, double h)
2201     {
2202         if (java.lang.Double.isNaN(x+w) || java.lang.Double.isNaN(y+h)) {
2203             /* [xy]+[wh] is NaN if any of those values are NaN,
2204              * or if adding the two together would produce NaN
2205              * by virtue of adding opposing Infinte values.
2206              * Since we need to add them below, their sum must
2207              * not be NaN.
2208              * We return false because NaN always produces a
2209              * negative response to tests
2210              */
2211             return false;
2212         }
2213         if (w <= 0 || h <= 0) {
2214             return false;
2215         }
2216         int mask = (pi.getWindingRule() == WIND_NON_ZERO ? -1 : 2);
2217         int crossings = Curve.rectCrossingsForPath(pi, x, y, x+w, y+h);
2218         return (crossings != Curve.RECT_INTERSECTS &&
2219                 (crossings & mask) != 0);
2220     }
2221 
2222     /**
2223      * Tests if the specified {@link Rectangle2D} is entirely inside the
2224      * closed boundary of the specified {@link PathIterator}.
2225      * <p>
2226      * This method provides a basic facility for implementors of
2227      * the {@link Shape} interface to implement support for the
2228      * {@link Shape#contains(Rectangle2D)} method.
2229      * <p>
2230      * This method object may conservatively return false in
2231      * cases where the specified rectangular area intersects a
2232      * segment of the path, but that segment does not represent a
2233      * boundary between the interior and exterior of the path.
2234      * Such segments could lie entirely within the interior of the
2235      * path if they are part of a path with a {@link #WIND_NON_ZERO}
2236      * winding rule or if the segments are retraced in the reverse
2237      * direction such that the two sets of segments cancel each
2238      * other out without any exterior area falling between them.
2239      * To determine whether segments represent true boundaries of
2240      * the interior of the path would require extensive calculations
2241      * involving all of the segments of the path and the winding
2242      * rule and are thus beyond the scope of this implementation.
2243      *
2244      * @param pi the specified {@code PathIterator}
2245      * @param r a specified {@code Rectangle2D}
2246      * @return {@code true} if the specified {@code PathIterator} contains
2247      *         the specified {@code Rectangle2D}; {@code false} otherwise.
2248      * @since 1.6
2249      */
2250     public static boolean contains(PathIterator pi, Rectangle2D r) {
2251         return contains(pi, r.getX(), r.getY(), r.getWidth(), r.getHeight());
2252     }
2253 
2254     /**
2255      * {@inheritDoc}
2256      * <p>
2257      * This method object may conservatively return false in
2258      * cases where the specified rectangular area intersects a
2259      * segment of the path, but that segment does not represent a
2260      * boundary between the interior and exterior of the path.
2261      * Such segments could lie entirely within the interior of the
2262      * path if they are part of a path with a {@link #WIND_NON_ZERO}
2263      * winding rule or if the segments are retraced in the reverse
2264      * direction such that the two sets of segments cancel each
2265      * other out without any exterior area falling between them.
2266      * To determine whether segments represent true boundaries of
2267      * the interior of the path would require extensive calculations
2268      * involving all of the segments of the path and the winding
2269      * rule and are thus beyond the scope of this implementation.
2270      *
2271      * @since 1.6
2272      */
2273     public final boolean contains(double x, double y, double w, double h) {
2274         if (java.lang.Double.isNaN(x+w) || java.lang.Double.isNaN(y+h)) {
2275             /* [xy]+[wh] is NaN if any of those values are NaN,
2276              * or if adding the two together would produce NaN
2277              * by virtue of adding opposing Infinte values.
2278              * Since we need to add them below, their sum must
2279              * not be NaN.
2280              * We return false because NaN always produces a
2281              * negative response to tests
2282              */
2283             return false;
2284         }
2285         if (w <= 0 || h <= 0) {
2286             return false;
2287         }
2288         int mask = (windingRule == WIND_NON_ZERO ? -1 : 2);
2289         int crossings = rectCrossings(x, y, x+w, y+h);
2290         return (crossings != Curve.RECT_INTERSECTS &&
2291                 (crossings & mask) != 0);
2292     }
2293 
2294     /**
2295      * {@inheritDoc}
2296      * <p>
2297      * This method object may conservatively return false in
2298      * cases where the specified rectangular area intersects a
2299      * segment of the path, but that segment does not represent a
2300      * boundary between the interior and exterior of the path.
2301      * Such segments could lie entirely within the interior of the
2302      * path if they are part of a path with a {@link #WIND_NON_ZERO}
2303      * winding rule or if the segments are retraced in the reverse
2304      * direction such that the two sets of segments cancel each
2305      * other out without any exterior area falling between them.
2306      * To determine whether segments represent true boundaries of
2307      * the interior of the path would require extensive calculations
2308      * involving all of the segments of the path and the winding
2309      * rule and are thus beyond the scope of this implementation.
2310      *
2311      * @since 1.6
2312      */
2313     public final boolean contains(Rectangle2D r) {
2314         return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
2315     }
2316 
2317     /**
2318      * Tests if the interior of the specified {@link PathIterator}
2319      * intersects the interior of a specified set of rectangular
2320      * coordinates.
2321      * <p>
2322      * This method provides a basic facility for implementors of
2323      * the {@link Shape} interface to implement support for the
2324      * {@link Shape#intersects(double, double, double, double)} method.
2325      * <p>
2326      * This method object may conservatively return true in
2327      * cases where the specified rectangular area intersects a
2328      * segment of the path, but that segment does not represent a
2329      * boundary between the interior and exterior of the path.
2330      * Such a case may occur if some set of segments of the
2331      * path are retraced in the reverse direction such that the
2332      * two sets of segments cancel each other out without any
2333      * interior area between them.
2334      * To determine whether segments represent true boundaries of
2335      * the interior of the path would require extensive calculations
2336      * involving all of the segments of the path and the winding
2337      * rule and are thus beyond the scope of this implementation.
2338      *
2339      * @param pi the specified {@code PathIterator}
2340      * @param x the specified X coordinate
2341      * @param y the specified Y coordinate
2342      * @param w the width of the specified rectangular coordinates
2343      * @param h the height of the specified rectangular coordinates
2344      * @return {@code true} if the specified {@code PathIterator} and
2345      *         the interior of the specified set of rectangular
2346      *         coordinates intersect each other; {@code false} otherwise.
2347      * @since 1.6
2348      */
2349     public static boolean intersects(PathIterator pi,
2350                                      double x, double y, double w, double h)
2351     {
2352         if (java.lang.Double.isNaN(x+w) || java.lang.Double.isNaN(y+h)) {
2353             /* [xy]+[wh] is NaN if any of those values are NaN,
2354              * or if adding the two together would produce NaN
2355              * by virtue of adding opposing Infinte values.
2356              * Since we need to add them below, their sum must
2357              * not be NaN.
2358              * We return false because NaN always produces a
2359              * negative response to tests
2360              */
2361             return false;
2362         }
2363         if (w <= 0 || h <= 0) {
2364             return false;
2365         }
2366         int mask = (pi.getWindingRule() == WIND_NON_ZERO ? -1 : 2);
2367         int crossings = Curve.rectCrossingsForPath(pi, x, y, x+w, y+h);
2368         return (crossings == Curve.RECT_INTERSECTS ||
2369                 (crossings & mask) != 0);
2370     }
2371 
2372     /**
2373      * Tests if the interior of the specified {@link PathIterator}
2374      * intersects the interior of a specified {@link Rectangle2D}.
2375      * <p>
2376      * This method provides a basic facility for implementors of
2377      * the {@link Shape} interface to implement support for the
2378      * {@link Shape#intersects(Rectangle2D)} method.
2379      * <p>
2380      * This method object may conservatively return true in
2381      * cases where the specified rectangular area intersects a
2382      * segment of the path, but that segment does not represent a
2383      * boundary between the interior and exterior of the path.
2384      * Such a case may occur if some set of segments of the
2385      * path are retraced in the reverse direction such that the
2386      * two sets of segments cancel each other out without any
2387      * interior area between them.
2388      * To determine whether segments represent true boundaries of
2389      * the interior of the path would require extensive calculations
2390      * involving all of the segments of the path and the winding
2391      * rule and are thus beyond the scope of this implementation.
2392      *
2393      * @param pi the specified {@code PathIterator}
2394      * @param r the specified {@code Rectangle2D}
2395      * @return {@code true} if the specified {@code PathIterator} and
2396      *         the interior of the specified {@code Rectangle2D}
2397      *         intersect each other; {@code false} otherwise.
2398      * @since 1.6
2399      */
2400     public static boolean intersects(PathIterator pi, Rectangle2D r) {
2401         return intersects(pi, r.getX(), r.getY(), r.getWidth(), r.getHeight());
2402     }
2403 
2404     /**
2405      * {@inheritDoc}
2406      * <p>
2407      * This method object may conservatively return true in
2408      * cases where the specified rectangular area intersects a
2409      * segment of the path, but that segment does not represent a
2410      * boundary between the interior and exterior of the path.
2411      * Such a case may occur if some set of segments of the
2412      * path are retraced in the reverse direction such that the
2413      * two sets of segments cancel each other out without any
2414      * interior area between them.
2415      * To determine whether segments represent true boundaries of
2416      * the interior of the path would require extensive calculations
2417      * involving all of the segments of the path and the winding
2418      * rule and are thus beyond the scope of this implementation.
2419      *
2420      * @since 1.6
2421      */
2422     public final boolean intersects(double x, double y, double w, double h) {
2423         if (java.lang.Double.isNaN(x+w) || java.lang.Double.isNaN(y+h)) {
2424             /* [xy]+[wh] is NaN if any of those values are NaN,
2425              * or if adding the two together would produce NaN
2426              * by virtue of adding opposing Infinte values.
2427              * Since we need to add them below, their sum must
2428              * not be NaN.
2429              * We return false because NaN always produces a
2430              * negative response to tests
2431              */
2432             return false;
2433         }
2434         if (w <= 0 || h <= 0) {
2435             return false;
2436         }
2437         int mask = (windingRule == WIND_NON_ZERO ? -1 : 2);
2438         int crossings = rectCrossings(x, y, x+w, y+h);
2439         return (crossings == Curve.RECT_INTERSECTS ||
2440                 (crossings & mask) != 0);
2441     }
2442 
2443     /**
2444      * {@inheritDoc}
2445      * <p>
2446      * This method object may conservatively return true in
2447      * cases where the specified rectangular area intersects a
2448      * segment of the path, but that segment does not represent a
2449      * boundary between the interior and exterior of the path.
2450      * Such a case may occur if some set of segments of the
2451      * path are retraced in the reverse direction such that the
2452      * two sets of segments cancel each other out without any
2453      * interior area between them.
2454      * To determine whether segments represent true boundaries of
2455      * the interior of the path would require extensive calculations
2456      * involving all of the segments of the path and the winding
2457      * rule and are thus beyond the scope of this implementation.
2458      *
2459      * @since 1.6
2460      */
2461     public final boolean intersects(Rectangle2D r) {
2462         return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
2463     }
2464 
2465     /**
2466      * {@inheritDoc}
2467      * <p>
2468      * The iterator for this class is not multi-threaded safe,
2469      * which means that this {@code Path2D} class does not
2470      * guarantee that modifications to the geometry of this
2471      * {@code Path2D} object do not affect any iterations of
2472      * that geometry that are already in process.
2473      *
2474      * @since 1.6
2475      */
2476     public final PathIterator getPathIterator(AffineTransform at,
2477                                               double flatness)
2478     {
2479         return new FlatteningPathIterator(getPathIterator(at), flatness);
2480     }
2481 
2482     /**
2483      * Creates a new object of the same class as this object.
2484      *
2485      * @return     a clone of this instance.
2486      * @exception  OutOfMemoryError            if there is not enough memory.
2487      * @see        java.lang.Cloneable
2488      * @since      1.6
2489      */
2490     public abstract Object clone();
2491         // Note: It would be nice to have this return Path2D
2492         // but one of our subclasses (GeneralPath) needs to
2493         // offer "public Object clone()" for backwards
2494         // compatibility so we cannot restrict it further.
2495         // REMIND: Can we do both somehow?
2496 
2497     /**
2498      * Trims the capacity of this Path2D instance to its current
2499      * size. An application can use this operation to minimize the
2500      * storage of a path.
2501      * @return this Path2D instance
2502      * @Since 10
2503      */
2504     public abstract Path2D trimToSize();
2505 
2506     /*
2507      * Support fields and methods for serializing the subclasses.
2508      */
2509     private static final byte SERIAL_STORAGE_FLT_ARRAY = 0x30;
2510     private static final byte SERIAL_STORAGE_DBL_ARRAY = 0x31;
2511 
2512     private static final byte SERIAL_SEG_FLT_MOVETO    = 0x40;
2513     private static final byte SERIAL_SEG_FLT_LINETO    = 0x41;
2514     private static final byte SERIAL_SEG_FLT_QUADTO    = 0x42;
2515     private static final byte SERIAL_SEG_FLT_CUBICTO   = 0x43;
2516 
2517     private static final byte SERIAL_SEG_DBL_MOVETO    = 0x50;
2518     private static final byte SERIAL_SEG_DBL_LINETO    = 0x51;
2519     private static final byte SERIAL_SEG_DBL_QUADTO    = 0x52;
2520     private static final byte SERIAL_SEG_DBL_CUBICTO   = 0x53;
2521 
2522     private static final byte SERIAL_SEG_CLOSE         = 0x60;
2523     private static final byte SERIAL_PATH_END          = 0x61;
2524 
2525     final void writeObject(java.io.ObjectOutputStream s, boolean isdbl)
2526         throws java.io.IOException
2527     {
2528         s.defaultWriteObject();
2529 
2530         float fCoords[];
2531         double dCoords[];
2532 
2533         if (isdbl) {
2534             dCoords = ((Path2D.Double) this).doubleCoords;
2535             fCoords = null;
2536         } else {
2537             fCoords = ((Path2D.Float) this).floatCoords;
2538             dCoords = null;
2539         }
2540 
2541         int numTypes = this.numTypes;
2542 
2543         s.writeByte(isdbl
2544                     ? SERIAL_STORAGE_DBL_ARRAY
2545                     : SERIAL_STORAGE_FLT_ARRAY);
2546         s.writeInt(numTypes);
2547         s.writeInt(numCoords);
2548         s.writeByte((byte) windingRule);
2549 
2550         int cindex = 0;
2551         for (int i = 0; i < numTypes; i++) {
2552             int npoints;
2553             byte serialtype;
2554             switch (pointTypes[i]) {
2555             case SEG_MOVETO:
2556                 npoints = 1;
2557                 serialtype = (isdbl
2558                               ? SERIAL_SEG_DBL_MOVETO
2559                               : SERIAL_SEG_FLT_MOVETO);
2560                 break;
2561             case SEG_LINETO:
2562                 npoints = 1;
2563                 serialtype = (isdbl
2564                               ? SERIAL_SEG_DBL_LINETO
2565                               : SERIAL_SEG_FLT_LINETO);
2566                 break;
2567             case SEG_QUADTO:
2568                 npoints = 2;
2569                 serialtype = (isdbl
2570                               ? SERIAL_SEG_DBL_QUADTO
2571                               : SERIAL_SEG_FLT_QUADTO);
2572                 break;
2573             case SEG_CUBICTO:
2574                 npoints = 3;
2575                 serialtype = (isdbl
2576                               ? SERIAL_SEG_DBL_CUBICTO
2577                               : SERIAL_SEG_FLT_CUBICTO);
2578                 break;
2579             case SEG_CLOSE:
2580                 npoints = 0;
2581                 serialtype = SERIAL_SEG_CLOSE;
2582                 break;
2583 
2584             default:
2585                 // Should never happen
2586                 throw new InternalError("unrecognized path type");
2587             }
2588             s.writeByte(serialtype);
2589             while (--npoints >= 0) {
2590                 if (isdbl) {
2591                     s.writeDouble(dCoords[cindex++]);
2592                     s.writeDouble(dCoords[cindex++]);
2593                 } else {
2594                     s.writeFloat(fCoords[cindex++]);
2595                     s.writeFloat(fCoords[cindex++]);
2596                 }
2597             }
2598         }
2599         s.writeByte(SERIAL_PATH_END);
2600     }
2601 
2602     final void readObject(java.io.ObjectInputStream s, boolean storedbl)
2603         throws java.lang.ClassNotFoundException, java.io.IOException
2604     {
2605         s.defaultReadObject();
2606 
2607         // The subclass calls this method with the storage type that
2608         // they want us to use (storedbl) so we ignore the storage
2609         // method hint from the stream.
2610         s.readByte();
2611         int nT = s.readInt();
2612         int nC = s.readInt();
2613         try {
2614             setWindingRule(s.readByte());
2615         } catch (IllegalArgumentException iae) {
2616             throw new java.io.InvalidObjectException(iae.getMessage());
2617         }
2618 
2619         pointTypes = new byte[(nT < 0) ? INIT_SIZE : nT];
2620         if (nC < 0) {
2621             nC = INIT_SIZE * 2;
2622         }
2623         if (storedbl) {
2624             ((Path2D.Double) this).doubleCoords = new double[nC];
2625         } else {
2626             ((Path2D.Float) this).floatCoords = new float[nC];
2627         }
2628 
2629     PATHDONE:
2630         for (int i = 0; nT < 0 || i < nT; i++) {
2631             boolean isdbl;
2632             int npoints;
2633             byte segtype;
2634 
2635             byte serialtype = s.readByte();
2636             switch (serialtype) {
2637             case SERIAL_SEG_FLT_MOVETO:
2638                 isdbl = false;
2639                 npoints = 1;
2640                 segtype = SEG_MOVETO;
2641                 break;
2642             case SERIAL_SEG_FLT_LINETO:
2643                 isdbl = false;
2644                 npoints = 1;
2645                 segtype = SEG_LINETO;
2646                 break;
2647             case SERIAL_SEG_FLT_QUADTO:
2648                 isdbl = false;
2649                 npoints = 2;
2650                 segtype = SEG_QUADTO;
2651                 break;
2652             case SERIAL_SEG_FLT_CUBICTO:
2653                 isdbl = false;
2654                 npoints = 3;
2655                 segtype = SEG_CUBICTO;
2656                 break;
2657 
2658             case SERIAL_SEG_DBL_MOVETO:
2659                 isdbl = true;
2660                 npoints = 1;
2661                 segtype = SEG_MOVETO;
2662                 break;
2663             case SERIAL_SEG_DBL_LINETO:
2664                 isdbl = true;
2665                 npoints = 1;
2666                 segtype = SEG_LINETO;
2667                 break;
2668             case SERIAL_SEG_DBL_QUADTO:
2669                 isdbl = true;
2670                 npoints = 2;
2671                 segtype = SEG_QUADTO;
2672                 break;
2673             case SERIAL_SEG_DBL_CUBICTO:
2674                 isdbl = true;
2675                 npoints = 3;
2676                 segtype = SEG_CUBICTO;
2677                 break;
2678 
2679             case SERIAL_SEG_CLOSE:
2680                 isdbl = false;
2681                 npoints = 0;
2682                 segtype = SEG_CLOSE;
2683                 break;
2684 
2685             case SERIAL_PATH_END:
2686                 if (nT < 0) {
2687                     break PATHDONE;
2688                 }
2689                 throw new StreamCorruptedException("unexpected PATH_END");
2690 
2691             default:
2692                 throw new StreamCorruptedException("unrecognized path type");
2693             }
2694             needRoom(segtype != SEG_MOVETO, npoints * 2);
2695             if (isdbl) {
2696                 while (--npoints >= 0) {
2697                     append(s.readDouble(), s.readDouble());
2698                 }
2699             } else {
2700                 while (--npoints >= 0) {
2701                     append(s.readFloat(), s.readFloat());
2702                 }
2703             }
2704             pointTypes[numTypes++] = segtype;
2705         }
2706         if (nT >= 0 && s.readByte() != SERIAL_PATH_END) {
2707             throw new StreamCorruptedException("missing PATH_END");
2708         }
2709     }
2710 
2711     abstract static class Iterator implements PathIterator {
2712         int typeIdx;
2713         int pointIdx;
2714         Path2D path;
2715 
2716         static final int curvecoords[] = {2, 2, 4, 6, 0};
2717 
2718         Iterator(Path2D path) {
2719             this.path = path;
2720         }
2721 
2722         public int getWindingRule() {
2723             return path.getWindingRule();
2724         }
2725 
2726         public boolean isDone() {
2727             return (typeIdx >= path.numTypes);
2728         }
2729 
2730         public void next() {
2731             int type = path.pointTypes[typeIdx++];
2732             pointIdx += curvecoords[type];
2733         }
2734     }
2735 }
--- EOF ---