Home » openjdk-7 » java » awt » [javadoc | source]

    1   /*
    2    * Copyright (c) 1995, 2006, 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   package java.awt;
   26   
   27   import java.awt.geom.AffineTransform;
   28   import java.awt.geom.PathIterator;
   29   import java.awt.geom.Point2D;
   30   import java.awt.geom.Rectangle2D;
   31   import sun.awt.geom.Crossings;
   32   import java.util.Arrays;
   33   
   34   /**
   35    * The <code>Polygon</code> class encapsulates a description of a
   36    * closed, two-dimensional region within a coordinate space. This
   37    * region is bounded by an arbitrary number of line segments, each of
   38    * which is one side of the polygon. Internally, a polygon
   39    * comprises of a list of {@code (x,y)}
   40    * coordinate pairs, where each pair defines a <i>vertex</i> of the
   41    * polygon, and two successive pairs are the endpoints of a
   42    * line that is a side of the polygon. The first and final
   43    * pairs of {@code (x,y)} points are joined by a line segment
   44    * that closes the polygon.  This <code>Polygon</code> is defined with
   45    * an even-odd winding rule.  See
   46    * {@link java.awt.geom.PathIterator#WIND_EVEN_ODD WIND_EVEN_ODD}
   47    * for a definition of the even-odd winding rule.
   48    * This class's hit-testing methods, which include the
   49    * <code>contains</code>, <code>intersects</code> and <code>inside</code>
   50    * methods, use the <i>insideness</i> definition described in the
   51    * {@link Shape} class comments.
   52    *
   53    * @author      Sami Shaio
   54    * @see Shape
   55    * @author      Herb Jellinek
   56    * @since       1.0
   57    */
   58   public class Polygon implements Shape, java.io.Serializable {
   59   
   60       /**
   61        * The total number of points.  The value of <code>npoints</code>
   62        * represents the number of valid points in this <code>Polygon</code>
   63        * and might be less than the number of elements in
   64        * {@link #xpoints xpoints} or {@link #ypoints ypoints}.
   65        * This value can be NULL.
   66        *
   67        * @serial
   68        * @see #addPoint(int, int)
   69        * @since 1.0
   70        */
   71       public int npoints;
   72   
   73       /**
   74        * The array of X coordinates.  The number of elements in
   75        * this array might be more than the number of X coordinates
   76        * in this <code>Polygon</code>.  The extra elements allow new points
   77        * to be added to this <code>Polygon</code> without re-creating this
   78        * array.  The value of {@link #npoints npoints} is equal to the
   79        * number of valid points in this <code>Polygon</code>.
   80        *
   81        * @serial
   82        * @see #addPoint(int, int)
   83        * @since 1.0
   84        */
   85       public int xpoints[];
   86   
   87       /**
   88        * The array of Y coordinates.  The number of elements in
   89        * this array might be more than the number of Y coordinates
   90        * in this <code>Polygon</code>.  The extra elements allow new points
   91        * to be added to this <code>Polygon</code> without re-creating this
   92        * array.  The value of <code>npoints</code> is equal to the
   93        * number of valid points in this <code>Polygon</code>.
   94        *
   95        * @serial
   96        * @see #addPoint(int, int)
   97        * @since 1.0
   98        */
   99       public int ypoints[];
  100   
  101       /**
  102        * The bounds of this {@code Polygon}.
  103        * This value can be null.
  104        *
  105        * @serial
  106        * @see #getBoundingBox()
  107        * @see #getBounds()
  108        * @since 1.0
  109        */
  110       protected Rectangle bounds;
  111   
  112       /*
  113        * JDK 1.1 serialVersionUID
  114        */
  115       private static final long serialVersionUID = -6460061437900069969L;
  116   
  117       /*
  118        * Default length for xpoints and ypoints.
  119        */
  120       private static final int MIN_LENGTH = 4;
  121   
  122       /**
  123        * Creates an empty polygon.
  124        * @since 1.0
  125        */
  126       public Polygon() {
  127           xpoints = new int[MIN_LENGTH];
  128           ypoints = new int[MIN_LENGTH];
  129       }
  130   
  131       /**
  132        * Constructs and initializes a <code>Polygon</code> from the specified
  133        * parameters.
  134        * @param xpoints an array of X coordinates
  135        * @param ypoints an array of Y coordinates
  136        * @param npoints the total number of points in the
  137        *                          <code>Polygon</code>
  138        * @exception  NegativeArraySizeException if the value of
  139        *                       <code>npoints</code> is negative.
  140        * @exception  IndexOutOfBoundsException if <code>npoints</code> is
  141        *             greater than the length of <code>xpoints</code>
  142        *             or the length of <code>ypoints</code>.
  143        * @exception  NullPointerException if <code>xpoints</code> or
  144        *             <code>ypoints</code> is <code>null</code>.
  145        * @since 1.0
  146        */
  147       public Polygon(int xpoints[], int ypoints[], int npoints) {
  148           // Fix 4489009: should throw IndexOutofBoundsException instead
  149           // of OutofMemoryException if npoints is huge and > {x,y}points.length
  150           if (npoints > xpoints.length || npoints > ypoints.length) {
  151               throw new IndexOutOfBoundsException("npoints > xpoints.length || "+
  152                                                   "npoints > ypoints.length");
  153           }
  154           // Fix 6191114: should throw NegativeArraySizeException with
  155           // negative npoints
  156           if (npoints < 0) {
  157               throw new NegativeArraySizeException("npoints < 0");
  158           }
  159           // Fix 6343431: Applet compatibility problems if arrays are not
  160           // exactly npoints in length
  161           this.npoints = npoints;
  162           this.xpoints = Arrays.copyOf(xpoints, npoints);
  163           this.ypoints = Arrays.copyOf(ypoints, npoints);
  164       }
  165   
  166       /**
  167        * Resets this <code>Polygon</code> object to an empty polygon.
  168        * The coordinate arrays and the data in them are left untouched
  169        * but the number of points is reset to zero to mark the old
  170        * vertex data as invalid and to start accumulating new vertex
  171        * data at the beginning.
  172        * All internally-cached data relating to the old vertices
  173        * are discarded.
  174        * Note that since the coordinate arrays from before the reset
  175        * are reused, creating a new empty <code>Polygon</code> might
  176        * be more memory efficient than resetting the current one if
  177        * the number of vertices in the new polygon data is significantly
  178        * smaller than the number of vertices in the data from before the
  179        * reset.
  180        * @see         java.awt.Polygon#invalidate
  181        * @since 1.4
  182        */
  183       public void reset() {
  184           npoints = 0;
  185           bounds = null;
  186       }
  187   
  188       /**
  189        * Invalidates or flushes any internally-cached data that depends
  190        * on the vertex coordinates of this <code>Polygon</code>.
  191        * This method should be called after any direct manipulation
  192        * of the coordinates in the <code>xpoints</code> or
  193        * <code>ypoints</code> arrays to avoid inconsistent results
  194        * from methods such as <code>getBounds</code> or <code>contains</code>
  195        * that might cache data from earlier computations relating to
  196        * the vertex coordinates.
  197        * @see         java.awt.Polygon#getBounds
  198        * @since 1.4
  199        */
  200       public void invalidate() {
  201           bounds = null;
  202       }
  203   
  204       /**
  205        * Translates the vertices of the <code>Polygon</code> by
  206        * <code>deltaX</code> along the x axis and by
  207        * <code>deltaY</code> along the y axis.
  208        * @param deltaX the amount to translate along the X axis
  209        * @param deltaY the amount to translate along the Y axis
  210        * @since 1.1
  211        */
  212       public void translate(int deltaX, int deltaY) {
  213           for (int i = 0; i < npoints; i++) {
  214               xpoints[i] += deltaX;
  215               ypoints[i] += deltaY;
  216           }
  217           if (bounds != null) {
  218               bounds.translate(deltaX, deltaY);
  219           }
  220       }
  221   
  222       /*
  223        * Calculates the bounding box of the points passed to the constructor.
  224        * Sets <code>bounds</code> to the result.
  225        * @param xpoints[] array of <i>x</i> coordinates
  226        * @param ypoints[] array of <i>y</i> coordinates
  227        * @param npoints the total number of points
  228        */
  229       void calculateBounds(int xpoints[], int ypoints[], int npoints) {
  230           int boundsMinX = Integer.MAX_VALUE;
  231           int boundsMinY = Integer.MAX_VALUE;
  232           int boundsMaxX = Integer.MIN_VALUE;
  233           int boundsMaxY = Integer.MIN_VALUE;
  234   
  235           for (int i = 0; i < npoints; i++) {
  236               int x = xpoints[i];
  237               boundsMinX = Math.min(boundsMinX, x);
  238               boundsMaxX = Math.max(boundsMaxX, x);
  239               int y = ypoints[i];
  240               boundsMinY = Math.min(boundsMinY, y);
  241               boundsMaxY = Math.max(boundsMaxY, y);
  242           }
  243           bounds = new Rectangle(boundsMinX, boundsMinY,
  244                                  boundsMaxX - boundsMinX,
  245                                  boundsMaxY - boundsMinY);
  246       }
  247   
  248       /*
  249        * Resizes the bounding box to accomodate the specified coordinates.
  250        * @param x,&nbsp;y the specified coordinates
  251        */
  252       void updateBounds(int x, int y) {
  253           if (x < bounds.x) {
  254               bounds.width = bounds.width + (bounds.x - x);
  255               bounds.x = x;
  256           }
  257           else {
  258               bounds.width = Math.max(bounds.width, x - bounds.x);
  259               // bounds.x = bounds.x;
  260           }
  261   
  262           if (y < bounds.y) {
  263               bounds.height = bounds.height + (bounds.y - y);
  264               bounds.y = y;
  265           }
  266           else {
  267               bounds.height = Math.max(bounds.height, y - bounds.y);
  268               // bounds.y = bounds.y;
  269           }
  270       }
  271   
  272       /**
  273        * Appends the specified coordinates to this <code>Polygon</code>.
  274        * <p>
  275        * If an operation that calculates the bounding box of this
  276        * <code>Polygon</code> has already been performed, such as
  277        * <code>getBounds</code> or <code>contains</code>, then this
  278        * method updates the bounding box.
  279        * @param       x the specified X coordinate
  280        * @param       y the specified Y coordinate
  281        * @see         java.awt.Polygon#getBounds
  282        * @see         java.awt.Polygon#contains
  283        * @since 1.0
  284        */
  285       public void addPoint(int x, int y) {
  286           if (npoints >= xpoints.length || npoints >= ypoints.length) {
  287               int newLength = npoints * 2;
  288               // Make sure that newLength will be greater than MIN_LENGTH and
  289               // aligned to the power of 2
  290               if (newLength < MIN_LENGTH) {
  291                   newLength = MIN_LENGTH;
  292               } else if ((newLength & (newLength - 1)) != 0) {
  293                   newLength = Integer.highestOneBit(newLength);
  294               }
  295   
  296               xpoints = Arrays.copyOf(xpoints, newLength);
  297               ypoints = Arrays.copyOf(ypoints, newLength);
  298           }
  299           xpoints[npoints] = x;
  300           ypoints[npoints] = y;
  301           npoints++;
  302           if (bounds != null) {
  303               updateBounds(x, y);
  304           }
  305       }
  306   
  307       /**
  308        * Gets the bounding box of this <code>Polygon</code>.
  309        * The bounding box is the smallest {@link Rectangle} whose
  310        * sides are parallel to the x and y axes of the
  311        * coordinate space, and can completely contain the <code>Polygon</code>.
  312        * @return a <code>Rectangle</code> that defines the bounds of this
  313        * <code>Polygon</code>.
  314        * @since 1.1
  315        */
  316       public Rectangle getBounds() {
  317           return getBoundingBox();
  318       }
  319   
  320       /**
  321        * Returns the bounds of this <code>Polygon</code>.
  322        * @return the bounds of this <code>Polygon</code>.
  323        * @deprecated As of JDK version 1.1,
  324        * replaced by <code>getBounds()</code>.
  325        * @since 1.0
  326        */
  327       @Deprecated
  328       public Rectangle getBoundingBox() {
  329           if (npoints == 0) {
  330               return new Rectangle();
  331           }
  332           if (bounds == null) {
  333               calculateBounds(xpoints, ypoints, npoints);
  334           }
  335           return bounds.getBounds();
  336       }
  337   
  338       /**
  339        * Determines whether the specified {@link Point} is inside this
  340        * <code>Polygon</code>.
  341        * @param p the specified <code>Point</code> to be tested
  342        * @return <code>true</code> if the <code>Polygon</code> contains the
  343        *                  <code>Point</code>; <code>false</code> otherwise.
  344        * @see #contains(double, double)
  345        * @since 1.0
  346        */
  347       public boolean contains(Point p) {
  348           return contains(p.x, p.y);
  349       }
  350   
  351       /**
  352        * Determines whether the specified coordinates are inside this
  353        * <code>Polygon</code>.
  354        * <p>
  355        * @param x the specified X coordinate to be tested
  356        * @param y the specified Y coordinate to be tested
  357        * @return {@code true} if this {@code Polygon} contains
  358        *         the specified coordinates {@code (x,y)};
  359        *         {@code false} otherwise.
  360        * @see #contains(double, double)
  361        * @since 1.1
  362        */
  363       public boolean contains(int x, int y) {
  364           return contains((double) x, (double) y);
  365       }
  366   
  367       /**
  368        * Determines whether the specified coordinates are contained in this
  369        * <code>Polygon</code>.
  370        * @param x the specified X coordinate to be tested
  371        * @param y the specified Y coordinate to be tested
  372        * @return {@code true} if this {@code Polygon} contains
  373        *         the specified coordinates {@code (x,y)};
  374        *         {@code false} otherwise.
  375        * @see #contains(double, double)
  376        * @deprecated As of JDK version 1.1,
  377        * replaced by <code>contains(int, int)</code>.
  378        * @since 1.0
  379        */
  380       @Deprecated
  381       public boolean inside(int x, int y) {
  382           return contains((double) x, (double) y);
  383       }
  384   
  385       /**
  386        * {@inheritDoc}
  387        * @since 1.2
  388        */
  389       public Rectangle2D getBounds2D() {
  390           return getBounds();
  391       }
  392   
  393       /**
  394        * {@inheritDoc}
  395        * @since 1.2
  396        */
  397       public boolean contains(double x, double y) {
  398           if (npoints <= 2 || !getBoundingBox().contains(x, y)) {
  399               return false;
  400           }
  401           int hits = 0;
  402   
  403           int lastx = xpoints[npoints - 1];
  404           int lasty = ypoints[npoints - 1];
  405           int curx, cury;
  406   
  407           // Walk the edges of the polygon
  408           for (int i = 0; i < npoints; lastx = curx, lasty = cury, i++) {
  409               curx = xpoints[i];
  410               cury = ypoints[i];
  411   
  412               if (cury == lasty) {
  413                   continue;
  414               }
  415   
  416               int leftx;
  417               if (curx < lastx) {
  418                   if (x >= lastx) {
  419                       continue;
  420                   }
  421                   leftx = curx;
  422               } else {
  423                   if (x >= curx) {
  424                       continue;
  425                   }
  426                   leftx = lastx;
  427               }
  428   
  429               double test1, test2;
  430               if (cury < lasty) {
  431                   if (y < cury || y >= lasty) {
  432                       continue;
  433                   }
  434                   if (x < leftx) {
  435                       hits++;
  436                       continue;
  437                   }
  438                   test1 = x - curx;
  439                   test2 = y - cury;
  440               } else {
  441                   if (y < lasty || y >= cury) {
  442                       continue;
  443                   }
  444                   if (x < leftx) {
  445                       hits++;
  446                       continue;
  447                   }
  448                   test1 = x - lastx;
  449                   test2 = y - lasty;
  450               }
  451   
  452               if (test1 < (test2 / (lasty - cury) * (lastx - curx))) {
  453                   hits++;
  454               }
  455           }
  456   
  457           return ((hits & 1) != 0);
  458       }
  459   
  460       private Crossings getCrossings(double xlo, double ylo,
  461                                      double xhi, double yhi)
  462       {
  463           Crossings cross = new Crossings.EvenOdd(xlo, ylo, xhi, yhi);
  464           int lastx = xpoints[npoints - 1];
  465           int lasty = ypoints[npoints - 1];
  466           int curx, cury;
  467   
  468           // Walk the edges of the polygon
  469           for (int i = 0; i < npoints; i++) {
  470               curx = xpoints[i];
  471               cury = ypoints[i];
  472               if (cross.accumulateLine(lastx, lasty, curx, cury)) {
  473                   return null;
  474               }
  475               lastx = curx;
  476               lasty = cury;
  477           }
  478   
  479           return cross;
  480       }
  481   
  482       /**
  483        * {@inheritDoc}
  484        * @since 1.2
  485        */
  486       public boolean contains(Point2D p) {
  487           return contains(p.getX(), p.getY());
  488       }
  489   
  490       /**
  491        * {@inheritDoc}
  492        * @since 1.2
  493        */
  494       public boolean intersects(double x, double y, double w, double h) {
  495           if (npoints <= 0 || !getBoundingBox().intersects(x, y, w, h)) {
  496               return false;
  497           }
  498   
  499           Crossings cross = getCrossings(x, y, x+w, y+h);
  500           return (cross == null || !cross.isEmpty());
  501       }
  502   
  503       /**
  504        * {@inheritDoc}
  505        * @since 1.2
  506        */
  507       public boolean intersects(Rectangle2D r) {
  508           return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
  509       }
  510   
  511       /**
  512        * {@inheritDoc}
  513        * @since 1.2
  514        */
  515       public boolean contains(double x, double y, double w, double h) {
  516           if (npoints <= 0 || !getBoundingBox().intersects(x, y, w, h)) {
  517               return false;
  518           }
  519   
  520           Crossings cross = getCrossings(x, y, x+w, y+h);
  521           return (cross != null && cross.covers(y, y+h));
  522       }
  523   
  524       /**
  525        * {@inheritDoc}
  526        * @since 1.2
  527        */
  528       public boolean contains(Rectangle2D r) {
  529           return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
  530       }
  531   
  532       /**
  533        * Returns an iterator object that iterates along the boundary of this
  534        * <code>Polygon</code> and provides access to the geometry
  535        * of the outline of this <code>Polygon</code>.  An optional
  536        * {@link AffineTransform} can be specified so that the coordinates
  537        * returned in the iteration are transformed accordingly.
  538        * @param at an optional <code>AffineTransform</code> to be applied to the
  539        *          coordinates as they are returned in the iteration, or
  540        *          <code>null</code> if untransformed coordinates are desired
  541        * @return a {@link PathIterator} object that provides access to the
  542        *          geometry of this <code>Polygon</code>.
  543        * @since 1.2
  544        */
  545       public PathIterator getPathIterator(AffineTransform at) {
  546           return new PolygonPathIterator(this, at);
  547       }
  548   
  549       /**
  550        * Returns an iterator object that iterates along the boundary of
  551        * the <code>Shape</code> and provides access to the geometry of the
  552        * outline of the <code>Shape</code>.  Only SEG_MOVETO, SEG_LINETO, and
  553        * SEG_CLOSE point types are returned by the iterator.
  554        * Since polygons are already flat, the <code>flatness</code> parameter
  555        * is ignored.  An optional <code>AffineTransform</code> can be specified
  556        * in which case the coordinates returned in the iteration are transformed
  557        * accordingly.
  558        * @param at an optional <code>AffineTransform</code> to be applied to the
  559        *          coordinates as they are returned in the iteration, or
  560        *          <code>null</code> if untransformed coordinates are desired
  561        * @param flatness the maximum amount that the control points
  562        *          for a given curve can vary from colinear before a subdivided
  563        *          curve is replaced by a straight line connecting the
  564        *          endpoints.  Since polygons are already flat the
  565        *          <code>flatness</code> parameter is ignored.
  566        * @return a <code>PathIterator</code> object that provides access to the
  567        *          <code>Shape</code> object's geometry.
  568        * @since 1.2
  569        */
  570       public PathIterator getPathIterator(AffineTransform at, double flatness) {
  571           return getPathIterator(at);
  572       }
  573   
  574       class PolygonPathIterator implements PathIterator {
  575           Polygon poly;
  576           AffineTransform transform;
  577           int index;
  578   
  579           public PolygonPathIterator(Polygon pg, AffineTransform at) {
  580               poly = pg;
  581               transform = at;
  582               if (pg.npoints == 0) {
  583                   // Prevent a spurious SEG_CLOSE segment
  584                   index = 1;
  585               }
  586           }
  587   
  588           /**
  589            * Returns the winding rule for determining the interior of the
  590            * path.
  591            * @return an integer representing the current winding rule.
  592            * @see PathIterator#WIND_NON_ZERO
  593            */
  594           public int getWindingRule() {
  595               return WIND_EVEN_ODD;
  596           }
  597   
  598           /**
  599            * Tests if there are more points to read.
  600            * @return <code>true</code> if there are more points to read;
  601            *          <code>false</code> otherwise.
  602            */
  603           public boolean isDone() {
  604               return index > poly.npoints;
  605           }
  606   
  607           /**
  608            * Moves the iterator forwards, along the primary direction of
  609            * traversal, to the next segment of the path when there are
  610            * more points in that direction.
  611            */
  612           public void next() {
  613               index++;
  614           }
  615   
  616           /**
  617            * Returns the coordinates and type of the current path segment in
  618            * the iteration.
  619            * The return value is the path segment type:
  620            * SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
  621            * A <code>float</code> array of length 2 must be passed in and
  622            * can be used to store the coordinates of the point(s).
  623            * Each point is stored as a pair of <code>float</code> x,&nbsp;y
  624            * coordinates.  SEG_MOVETO and SEG_LINETO types return one
  625            * point, and SEG_CLOSE does not return any points.
  626            * @param coords a <code>float</code> array that specifies the
  627            * coordinates of the point(s)
  628            * @return an integer representing the type and coordinates of the
  629            *              current path segment.
  630            * @see PathIterator#SEG_MOVETO
  631            * @see PathIterator#SEG_LINETO
  632            * @see PathIterator#SEG_CLOSE
  633            */
  634           public int currentSegment(float[] coords) {
  635               if (index >= poly.npoints) {
  636                   return SEG_CLOSE;
  637               }
  638               coords[0] = poly.xpoints[index];
  639               coords[1] = poly.ypoints[index];
  640               if (transform != null) {
  641                   transform.transform(coords, 0, coords, 0, 1);
  642               }
  643               return (index == 0 ? SEG_MOVETO : SEG_LINETO);
  644           }
  645   
  646           /**
  647            * Returns the coordinates and type of the current path segment in
  648            * the iteration.
  649            * The return value is the path segment type:
  650            * SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
  651            * A <code>double</code> array of length 2 must be passed in and
  652            * can be used to store the coordinates of the point(s).
  653            * Each point is stored as a pair of <code>double</code> x,&nbsp;y
  654            * coordinates.
  655            * SEG_MOVETO and SEG_LINETO types return one point,
  656            * and SEG_CLOSE does not return any points.
  657            * @param coords a <code>double</code> array that specifies the
  658            * coordinates of the point(s)
  659            * @return an integer representing the type and coordinates of the
  660            *              current path segment.
  661            * @see PathIterator#SEG_MOVETO
  662            * @see PathIterator#SEG_LINETO
  663            * @see PathIterator#SEG_CLOSE
  664            */
  665           public int currentSegment(double[] coords) {
  666               if (index >= poly.npoints) {
  667                   return SEG_CLOSE;
  668               }
  669               coords[0] = poly.xpoints[index];
  670               coords[1] = poly.ypoints[index];
  671               if (transform != null) {
  672                   transform.transform(coords, 0, coords, 0, 1);
  673               }
  674               return (index == 0 ? SEG_MOVETO : SEG_LINETO);
  675           }
  676       }
  677   }

Home » openjdk-7 » java » awt » [javadoc | source]