| 
 | JavaTM 2 Platform Std. Ed. v1.4.2 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||
java.lang.Objectjava.awt.geom.GeneralPath
The GeneralPath class represents a geometric path 
 constructed from straight lines, and quadratic and cubic
 (Bézier) curves.  It can contain multiple subpaths.
 
The winding rule specifies how the interior of a path is determined. There are two types of winding rules: EVEN_ODD and NON_ZERO.
An EVEN_ODD winding rule means that enclosed regions of the path alternate between interior and exterior areas as traversed from the outside of the path towards a point inside the region.
A NON_ZERO winding rule means that if a ray is drawn in any direction from a given point to infinity and the places where the path intersects the ray are examined, the point is inside of the path if and only if the number of times that the path crosses the ray from left to right does not equal the number of times that the path crosses the ray from right to left.
| Field Summary | |
| static int | WIND_EVEN_ODDAn even-odd winding rule for determining the interior of a path. | 
| static int | WIND_NON_ZEROA non-zero winding rule for determining the interior of a path. | 
| Constructor Summary | |
| GeneralPath()Constructs a new GeneralPathobject. | |
| GeneralPath(int rule)Constructs a new GeneralPathobject with the specified 
 winding rule to control operations that require the interior of the
 path to be defined. | |
| GeneralPath(int rule,
            int initialCapacity)Constructs a new GeneralPathobject with the specified 
 winding rule and the specified initial capacity to store path 
 coordinates. | |
| GeneralPath(Shape s)Constructs a new GeneralPathobject from an arbitraryShapeobject. | |
| Method Summary | |
|  void | append(PathIterator pi,
       boolean connect)Appends the geometry of the specified PathIteratorobject 
 to the path, possibly connecting the new geometry to the existing
 path segments with a line segment. | 
|  void | append(Shape s,
       boolean connect)Appends the geometry of the specified Shapeobject to the
 path, possibly connecting the new geometry to the existing path
 segments with a line segment. | 
|  Object | clone()Creates a new object of the same class as this object. | 
|  void | closePath()Closes the current subpath by drawing a straight line back to the coordinates of the last moveTo. | 
|  boolean | contains(double x,
         double y)Tests if the specified coordinates are inside the boundary of this Shape. | 
|  boolean | contains(double x,
         double y,
         double w,
         double h)Tests if the specified rectangular area is inside the boundary of this Shape. | 
|  boolean | contains(Point2D p)Tests if the specified Point2Dis inside the boundary
 of thisShape. | 
|  boolean | contains(Rectangle2D r)Tests if the specified Rectangle2Dis inside the boundary of thisShape. | 
|  Shape | createTransformedShape(AffineTransform at)Returns a new transformed Shape. | 
|  void | curveTo(float x1,
        float y1,
        float x2,
        float y2,
        float x3,
        float y3)Adds a curved segment, defined by three new points, to the path by drawing a Bézier curve that intersects both the current coordinates and the coordinates (x3, y3), using the specified points (x1, y1) and (x2, y2) as Bézier control points. | 
|  Rectangle | getBounds()Return the bounding box of the path. | 
|  Rectangle2D | getBounds2D()Returns the bounding box of the path. | 
|  Point2D | getCurrentPoint()Returns the coordinates most recently added to the end of the path as a Point2Dobject. | 
|  PathIterator | getPathIterator(AffineTransform at)Returns a PathIteratorobject that iterates along the 
 boundary of thisShapeand provides access to the 
 geometry of the outline of thisShape. | 
|  PathIterator | getPathIterator(AffineTransform at,
                double flatness)Returns a PathIteratorobject that iterates along the 
 boundary of the flattenedShapeand provides access to the 
 geometry of the outline of theShape. | 
|  int | getWindingRule()Returns the fill style winding rule. | 
|  boolean | intersects(double x,
           double y,
           double w,
           double h)Tests if the interior of this Shapeintersects the 
 interior of a specified set of rectangular coordinates. | 
|  boolean | intersects(Rectangle2D r)Tests if the interior of this Shapeintersects the 
 interior of a specifiedRectangle2D. | 
|  void | lineTo(float x,
       float y)Adds a point to the path by drawing a straight line from the current coordinates to the new specified coordinates. | 
|  void | moveTo(float x,
       float y)Adds a point to the path by moving to the specified coordinates. | 
|  void | quadTo(float x1,
       float y1,
       float x2,
       float y2)Adds a curved segment, defined by two new points, to the path by drawing a Quadratic curve that intersects both the current coordinates and the coordinates (x2, y2), using the specified point (x1, y1) as a quadratic parametric control point. | 
|  void | reset()Resets the path to empty. | 
|  void | setWindingRule(int rule)Sets the winding rule for this path to the specified value. | 
|  void | transform(AffineTransform at)Transforms the geometry of this path using the specified AffineTransform. | 
| Methods inherited from class java.lang.Object | 
| equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait | 
| Field Detail | 
public static final int WIND_EVEN_ODD
public static final int WIND_NON_ZERO
| Constructor Detail | 
public GeneralPath()
GeneralPath object.
 If an operation performed on this path requires the
 interior of the path to be defined then the default NON_ZERO
 winding rule is used.
WIND_NON_ZEROpublic GeneralPath(int rule)
GeneralPath object with the specified 
 winding rule to control operations that require the interior of the
 path to be defined.
rule - the winding ruleWIND_EVEN_ODD, 
WIND_NON_ZERO
public GeneralPath(int rule,
                   int initialCapacity)
GeneralPath object with the specified 
 winding rule and the specified initial capacity to store path 
 coordinates. This number is an initial guess as to how many path 
 segments are in the path, but the storage is expanded 
 as needed to store whatever path segments are added to this path.
rule - the winding ruleinitialCapacity - the estimate for the number of path segments
 in the pathWIND_EVEN_ODD, 
WIND_NON_ZEROpublic GeneralPath(Shape s)
GeneralPath object from an arbitrary 
 Shape object.
 All of the initial geometry and the winding rule for this path are
 taken from the specified Shape object.
s - the specified Shape object| Method Detail | 
public void moveTo(float x,
                   float y)
public void lineTo(float x,
                   float y)
public void quadTo(float x1,
                   float y1,
                   float x2,
                   float y2)
public void curveTo(float x1,
                    float y1,
                    float x2,
                    float y2,
                    float x3,
                    float y3)
public void closePath()
moveTo.  If the path is already
 closed then this method has no effect.
public void append(Shape s,
                   boolean connect)
Shape object to the
 path, possibly connecting the new geometry to the existing path
 segments with a line segment.
 If the connect parameter is true and the 
 path is not empty then any initial moveTo in the
 geometry of the appended Shape
 is turned into a lineTo segment.
 If the destination coordinates of such a connecting lineTo
 segment match the ending coordinates of a currently open
 subpath then the segment is omitted as superfluous.
 The winding rule of the specified Shape is ignored
 and the appended geometry is governed by the winding
 rule specified for this path.
s - the Shape whose geometry is appended 
 to this pathconnect - a boolean to control whether or not to turn an
 initial moveTo segment into a lineTo
 segment to connect the new geometry to the existing path
public void append(PathIterator pi,
                   boolean connect)
PathIterator object 
 to the path, possibly connecting the new geometry to the existing
 path segments with a line segment.
 If the connect parameter is true and the 
 path is not empty then any initial moveTo in the
 geometry of the appended Shape is turned into a
 lineTo segment.
 If the destination coordinates of such a connecting lineTo
 segment match the ending coordinates of a currently open
 subpath then the segment is omitted as superfluous.
 The winding rule of the specified Shape is ignored
 and the appended geometry is governed by the winding
 rule specified for this path.
pi - the PathIterator whose geometry is appended to 
 this pathconnect - a boolean to control whether or not to turn an
 initial moveTo segment into a lineTo segment
 to connect the new geometry to the existing pathpublic int getWindingRule()
WIND_EVEN_ODD, 
WIND_NON_ZERO, 
setWindingRule(int)public void setWindingRule(int rule)
rule - an integer representing the specified 
 winding rule
IllegalArgumentExceptionrule is not either 
		WIND_EVEN_ODD or
		WIND_NON_ZEROWIND_EVEN_ODD, 
WIND_NON_ZERO, 
getWindingRule()public Point2D getCurrentPoint()
Point2D object.
Point2D object containing the ending 
 coordinates of the path or null if there are no points
 in the path.public void reset()
public void transform(AffineTransform at)
AffineTransform.
 The geometry is transformed in place, which permanently changes the
 boundary defined by this object.
at - the AffineTransform used to transform the areapublic Shape createTransformedShape(AffineTransform at)
Shape.
at - the AffineTransform used to transform a 
 new Shape.
Shape, transformed with the specified 
 AffineTransform.public Rectangle getBounds()
getBounds in interface ShapeRectangle object that
 bounds the current path.Shape.getBounds2D()public Rectangle2D getBounds2D()
getBounds2D in interface ShapeRectangle2D object that
          bounds the current path.Shape.getBounds()
public boolean contains(double x,
                        double y)
Shape.
contains in interface Shapex - the specified x coordinatey - the specified y coordinate
true if the specified coordinates are inside this 
 Shape; false otherwisepublic boolean contains(Point2D p)
Point2D is inside the boundary
 of this Shape.
contains in interface Shapep - the specified Point2D
true if this Shape contains the 
 specified Point2D, false otherwise.
public boolean contains(double x,
                        double y,
                        double w,
                        double h)
Shape.
contains in interface Shapew - the width of the specified rectangular areah - the height of the specified rectangular areax - the x coordinate of the specified rectangular areay - the y coordinate of the specified rectangular area
true if this Shape contains 
 the specified rectangluar area; false otherwise.Area, 
Shape.intersects(double, double, double, double)public boolean contains(Rectangle2D r)
Rectangle2D
 is inside the boundary of this Shape.
contains in interface Shaper - a specified Rectangle2D
true if this Shape bounds the 
 specified Rectangle2D; false otherwise.Shape.contains(double, double, double, double)
public boolean intersects(double x,
                          double y,
                          double w,
                          double h)
Shape intersects the 
 interior of a specified set of rectangular coordinates.
intersects in interface Shapew - the width of the specified rectangular coordinatesh - the height of the specified rectangular coordinatesx - the x coordinate of the specified rectangular areay - the y coordinate of the specified rectangular area
true if this Shape and the 
 interior of the specified set of rectangular coordinates intersect
 each other; false otherwise.Areapublic boolean intersects(Rectangle2D r)
Shape intersects the 
 interior of a specified Rectangle2D.
intersects in interface Shaper - the specified Rectangle2D
true if this Shape and the interior 
 		of the specified Rectangle2D intersect each
 		other; false otherwise.Shape.intersects(double, double, double, double)public PathIterator getPathIterator(AffineTransform at)
PathIterator object that iterates along the 
 boundary of this Shape and provides access to the 
 geometry of the outline of this Shape.
 The iterator for this class is not multi-threaded safe,
 which means that this GeneralPath class does not
 guarantee that modifications to the geometry of this
 GeneralPath object do not affect any iterations of
 that geometry that are already in process.
getPathIterator in interface Shapeat - an AffineTransform
PathIterator that iterates along the 
 boundary of this Shape and provides access to the 
 geometry of this Shape's outline
public PathIterator getPathIterator(AffineTransform at,
                                    double flatness)
PathIterator object that iterates along the 
 boundary of the flattened Shape and provides access to the 
 geometry of the outline of the Shape.
 The iterator for this class is not multi-threaded safe,
 which means that this GeneralPath class does not
 guarantee that modifications to the geometry of this
 GeneralPath object do not affect any iterations of
 that geometry that are already in process.
getPathIterator in interface Shapeat - an AffineTransformflatness - the maximum distance that the line segments used to
		approximate the curved segments are allowed to deviate
		from any point on the original curve
PathIterator that iterates along the flattened
 Shape boundary.public Object clone()
clone in class ObjectOutOfMemoryError - if there is not enough memory.Cloneable| 
 | JavaTM 2 Platform Std. Ed. v1.4.2 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||
Copyright 2003 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.