libjava/java/awt/geom/GeneralPath.java

   1 /* GeneralPath.java -- represents a shape built from subpaths
   2    Copyright (C) 2002, 2003 Free Software Foundation
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.geom;
  40
  41 import java.awt.Rectangle;
  42 import java.awt.Shape;
  43
  44 /**
  45  * STUBS ONLY
  46  * XXX Implement and document. Note that Sun's implementation only expects
  47  * float precision, not double.
  48  */
  49 public final class GeneralPath implements Shape, Cloneable
  50 {
  51   public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;
  52   public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;
  53
  54   /** Initial size if not specified. */
  55   private static final int INIT_SIZE = 20;
  56
  57   /** The winding rule. */
  58   private int rule;
  59   /**
  60    * The path type in points. Note that points[index] maps to
  61    * types[index >> 1]; the control points of quad and cubic paths map as
  62    * well but are ignored.
  63    */
  64   private byte[] types;
  65   /**
  66    * The list of all points seen. Since you can only append floats, it makes
  67    * sense for this to be a float[]. I have no idea why Sun didn't choose to
  68    * allow a general path of double precision points.
  69    */
  70   private float[] points;
  71   /** The index of the most recent moveto point, or null. */
  72   private int subpath = -1;
  73   /** The next available index into points. */
  74   private int index;
  75
  76   public GeneralPath()
  77   {
  78     this(WIND_NON_ZERO, INIT_SIZE);
  79   }
  80   public GeneralPath(int rule)
  81   {
  82     this(rule, INIT_SIZE);
  83   }
  84   public GeneralPath(int rule, int capacity)
  85   {
  86     if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO)
  87       throw new IllegalArgumentException();
  88     this.rule = rule;
  89     if (capacity < INIT_SIZE)
  90       capacity = INIT_SIZE;
  91     types = new byte[capacity >> 1];
  92     points = new float[capacity];
  93   }
  94   public GeneralPath(Shape s)
  95   {
  96     types = new byte[INIT_SIZE >> 1];
  97     points = new float[INIT_SIZE];
  98     PathIterator pi = s.getPathIterator(null);
  99     setWindingRule(pi.getWindingRule());
 100     append(pi, false);
 101   }
 102
 103   public void moveTo(float x, float y)
 104   {
 105     subpath = index;
 106     ensureSize(index + 2);
 107     types[index >> 1] = PathIterator.SEG_MOVETO;
 108     points[index++] = x;
 109     points[index++] = y;
 110   }
 111   public void lineTo(float x, float y)
 112   {
 113     ensureSize(index + 2);
 114     types[index >> 1] = PathIterator.SEG_LINETO;
 115     points[index++] = x;
 116     points[index++] = y;
 117   }
 118   public void quadTo(float x1, float y1, float x2, float y2)
 119   {
 120     ensureSize(index + 4);
 121     types[index >> 1] = PathIterator.SEG_QUADTO;
 122     points[index++] = x1;
 123     points[index++] = y1;
 124     points[index++] = x2;
 125     points[index++] = y2;
 126   }
 127   public void curveTo(float x1, float y1, float x2, float y2,
 128                       float x3, float y3)
 129   {
 130     ensureSize(index + 6);
 131     types[index >> 1] = PathIterator.SEG_CUBICTO;
 132     points[index++] = x1;
 133     points[index++] = y1;
 134     points[index++] = x2;
 135     points[index++] = y2;
 136     points[index++] = x3;
 137     points[index++] = y3;
 138   }
 139   public void closePath()
 140   {
 141     ensureSize(index + 2);
 142     types[index >> 1] = PathIterator.SEG_CLOSE;
 143     points[index++] = points[subpath];
 144     points[index++] = points[subpath + 1];
 145   }
 146
 147   public void append(Shape s, boolean connect)
 148   {
 149     append(s.getPathIterator(null), connect);
 150   }
 151
 152
 153   /**
 154    * Appends the segments of a PathIterator to this GeneralPath.
 155    * Optionally, the initial {@link PathIterator#SEG_MOVETO} segment
 156    * of the appended path is changed into a {@link
 157    * PathIterator#SEG_LINETO} segment.
 158    *
 159    * @param iter the PathIterator specifying which segments shall be
 160    * appended.
 161    *
 162    * @param connect <code>true</code> for substituting the initial
 163    * {@link PathIterator#SEG_MOVETO} segment by a {@link
 164    * PathIterator#SEG_LINETO}, or <code>false</code> for not
 165    * performing any substitution. If this GeneralPath is currently
 166    * empty, <code>connect</code> is assumed to be <code>false</code>,
 167    * thus leaving the initial {@link PathIterator#SEG_MOVETO}
 168    * unchanged.
 169    */
 170   public void append(PathIterator iter, boolean connect)
 171   {
 172     // A bad implementation of this method had caused Classpath bug #6076.
 173     float[] f = new float[6];
 174     while (!iter.isDone())
 175     {
 176       switch (iter.currentSegment(f))
 177       {
 178       case PathIterator.SEG_MOVETO:
 179         if (!connect || (index == 0))
 180         {
 181           moveTo(f[0], f[1]);
 182           break;
 183         }
 184
 185         if ((index >= 2) && (types[(index - 2) >> 2] == PathIterator.SEG_CLOSE)
 186             && (f[0] == points[index - 2]) && (f[1] == points[index - 1]))
 187           break;
 188
 189         // Fall through.
 190
 191       case PathIterator.SEG_LINETO:
 192         lineTo(f[0], f[1]);
 193         break;
 194
 195       case PathIterator.SEG_QUADTO:
 196         quadTo(f[0], f[1], f[2], f[3]);
 197         break;
 198
 199       case PathIterator.SEG_CUBICTO:
 200         curveTo(f[0], f[1], f[2], f[3], f[4], f[5]);
 201         break;
 202
 203       case PathIterator.SEG_CLOSE:
 204         closePath();
 205         break;
 206       }
 207
 208       connect = false;
 209       iter.next();
 210     }
 211   }
 212
 213
 214   public int getWindingRule()
 215   {
 216     return rule;
 217   }
 218   public void setWindingRule(int rule)
 219   {
 220     if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO)
 221       throw new IllegalArgumentException();
 222     this.rule = rule;
 223   }
 224
 225   public Point2D getCurrentPoint()
 226   {
 227     if (subpath < 0)
 228       return null;
 229     return new Point2D.Float(points[index - 2], points[index - 1]);
 230   }
 231   public void reset()
 232   {
 233     subpath = -1;
 234     index = 0;
 235   }
 236
 237   public void transform(AffineTransform xform)
 238   {
 239     xform.transform(points, 0, points, 0, index >> 1);
 240   }
 241   public Shape createTransformedShape(AffineTransform xform)
 242   {
 243     GeneralPath p = new GeneralPath(this);
 244     p.transform(xform);
 245     return p;
 246   }
 247
 248   public Rectangle getBounds()
 249   {
 250     return getBounds2D().getBounds();
 251   }
 252   public Rectangle2D getBounds2D()
 253   {
 254     // XXX Implement.
 255     throw new Error("not implemented");
 256   }
 257
 258   public boolean contains(double x, double y)
 259   {
 260     // XXX Implement.
 261     throw new Error("not implemented");
 262   }
 263   public boolean contains(Point2D p)
 264   {
 265     return contains(p.getX(), p.getY());
 266   }
 267   public boolean contains(double x, double y, double w, double h)
 268   {
 269     // XXX Implement.
 270     throw new Error("not implemented");
 271   }
 272   public boolean contains(Rectangle2D r)
 273   {
 274     return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
 275   }
 276
 277   public boolean intersects(double x, double y, double w, double h)
 278   {
 279     // XXX Implement.
 280     throw new Error("not implemented");
 281   }
 282   public boolean intersects(Rectangle2D r)
 283   {
 284     return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
 285   }
 286
 287
 288   /**
 289    * A PathIterator that iterates over the segments of a GeneralPath.
 290    *
 291    * @author Sascha Brawer (brawer@dandelis.ch)
 292    */
 293   private static class GeneralPathIterator
 294     implements PathIterator
 295   {
 296     /**
 297      * The number of coordinate values for each segment type.
 298      */
 299     private static final int[] NUM_COORDS =
 300     {
 301       /* 0: SEG_MOVETO */ 2,
 302       /* 1: SEG_LINETO */ 2,
 303       /* 2: SEG_QUADTO */ 4,
 304       /* 3: SEG_CUBICTO */ 6,
 305       /* 4: SEG_CLOSE */ 0
 306     };
 307
 308
 309     /**
 310      * The GeneralPath whose segments are being iterated.
 311      */
 312     private final GeneralPath path;
 313
 314
 315     /**
 316      * The affine transformation used to transform coordinates.
 317      */
 318     private final AffineTransform transform;
 319
 320
 321     /**
 322      * The current position of the iterator.
 323      */
 324     private int pos;
 325
 326
 327     /**
 328      * Constructs a new iterator for enumerating the segments of a
 329      * GeneralPath.
 330      *
 331      * @param at an affine transformation for projecting the returned
 332      * points, or <code>null</code> to return the original points
 333      * without any mapping.
 334      */
 335     GeneralPathIterator(GeneralPath path, AffineTransform transform)
 336     {
 337       this.path = path;
 338       this.transform = transform;
 339     }
 340
 341
 342     /**
 343      * Returns the current winding rule of the GeneralPath.
 344      */
 345     public int getWindingRule()
 346     {
 347       return path.rule;
 348     }
 349
 350
 351     /**
 352      * Determines whether the iterator has reached the last segment in
 353      * the path.
 354      */
 355     public boolean isDone()
 356     {
 357       return pos >= path.index;
 358     }
 359
 360
 361     /**
 362      * Advances the iterator position by one segment.
 363      */
 364     public void next()
 365     {
 366       int seg;
 367
 368       /* Increment pos by the number of coordinate values. Note that
 369        * we store two values even for a SEG_CLOSE segment, which is
 370        * why we increment pos at least by 2.
 371        */
 372       seg = path.types[pos >> 1];
 373       if (seg == SEG_CLOSE)
 374         pos += 2;
 375       else
 376         pos += NUM_COORDS[seg];
 377     }
 378
 379
 380     /**
 381      * Returns the current segment in float coordinates.
 382      */
 383     public int currentSegment(float[] coords)
 384     {
 385       int seg, numCoords;
 386
 387       seg = path.types[pos >> 1];
 388       numCoords = NUM_COORDS[seg];
 389       if (numCoords > 0)
 390       {
 391         if (transform == null)
 392           System.arraycopy(path.points, pos, coords, 0, numCoords);
 393         else
 394           transform.transform(/* src */ path.points, /* srcOffset */ pos,
 395                               /* dest */ coords, /* destOffset */ 0,
 396                               /* numPoints */ numCoords >> 1);
 397       }
 398       return seg;
 399     }
 400
 401
 402     /**
 403      * Returns the current segment in double coordinates.
 404      */
 405     public int currentSegment(double[] coords)
 406     {
 407       int seg, numCoords;
 408
 409       seg = path.types[pos >> 1];
 410       numCoords = NUM_COORDS[seg];
 411       if (numCoords > 0)
 412       {
 413         if (transform == null)
 414         {
 415           // System.arraycopy throws an exception if the source and destination
 416           // array are not of the same primitive type.
 417           for (int i = 0; i < numCoords; i++)
 418             coords[i] = (double) path.points[pos + i];
 419         }
 420         else
 421           transform.transform(/* src */ path.points, /* srcOffset */ pos,
 422                               /* dest */ coords, /* destOffset */ 0,
 423                               /* numPoints */ numCoords >> 1);
 424       }
 425       return seg;
 426     }
 427   }
 428
 429
 430   /**
 431    * Creates a PathIterator for iterating along the segments of this path.
 432    *
 433    * @param at an affine transformation for projecting the returned
 434    * points, or <code>null</code> to let the created iterator return
 435    * the original points without any mapping.
 436    */
 437   public PathIterator getPathIterator(AffineTransform at)
 438   {
 439     return new GeneralPathIterator(this, at);
 440   }
 441
 442
 443   public PathIterator getPathIterator(AffineTransform at, double flatness)
 444   {
 445     return new FlatteningPathIterator(getPathIterator(at), flatness);
 446   }
 447
 448   /**
 449    * Create a new shape of the same run-time type with the same contents as
 450    * this one.
 451    *
 452    * @return the clone
 453    *
 454    * @exception OutOfMemoryError If there is not enough memory available.
 455    *
 456    * @since 1.2
 457    */
 458   public Object clone()
 459   {
 460     // This class is final; no need to use super.clone().
 461     return new GeneralPath(this);
 462   }
 463
 464   private void ensureSize(int size)
 465   {
 466     if (subpath < 0)
 467       throw new IllegalPathStateException("need initial moveto");
 468     if (size <= points.length)
 469       return;
 470     byte[] b = new byte[points.length];
 471     System.arraycopy(types, 0, b, 0, index >> 1);
 472     types = b;
 473     float[] f = new float[points.length << 1];
 474     System.arraycopy(points, 0, f, 0, index);
 475     points = f;
 476   }
 477 } // class GeneralPath