GeneralPath (Java 2 Platform SE v1.4.1_"07")

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

JavaTM 2 Platform
Std. Ed. v1.4.1_"07"

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt.geom
Class GeneralPath

    java.lang.Object
      |
      +--java.awt.geom.GeneralPath

All Implemented Interfaces:
  Cloneable, Shape

public final class GeneralPath
extends Object
implements Shape, Cloneable

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_ODD` An even-odd winding rule for determining the interior of a path.
`static int` | `WIND_NON_ZERO` A non-zero winding rule for determining the interior of a path.

Constructor Summary
`GeneralPath()` Constructs a new `GeneralPath` object.
`GeneralPath(int rule)` Constructs a new `GeneralPath` object 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 `GeneralPath` object with the specified winding rule and the specified initial capacity to store path coordinates.
`GeneralPath(Shape s)` Constructs a new `GeneralPath` object from an arbitrary `Shape` object.

Method Summary
`void` | `append(PathIterator pi, boolean connect)` Appends the geometry of the specified `PathIterator` object 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 `Shape` object 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 `Point2D` is inside the boundary of this `Shape`.
`boolean` | `contains(Rectangle2D r)` Tests if the specified `Rectangle2D` is inside the boundary of this `Shape`.
`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 `Point2D` object.
`PathIterator` | `getPathIterator(AffineTransform at)` Returns a `PathIterator` object that iterates along the boundary of this `Shape` and provides access to the geometry of the outline of this `Shape`.
`PathIterator` | `getPathIterator(AffineTransform at, double flatness)` Returns a `PathIterator` object that iterates along the boundary of the flattened `Shape` and provides access to the geometry of the outline of the `Shape`.
`int` | `getWindingRule()` Returns the fill style winding rule.
`boolean` | `intersects(double x, double y, double w, double h)` Tests if the interior of this `Shape` intersects the interior of a specified set of rectangular coordinates.
`boolean` | `intersects(Rectangle2D r)` Tests if the interior of this `Shape` intersects the interior of a specified `Rectangle2D`.
`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

### WIND_EVEN_ODD

    public static final int WIND_EVEN_ODD

  An even-odd winding rule for determining the interior of a path.

  See Also:
    Constant Field Values

### WIND_NON_ZERO

    public static final int WIND_NON_ZERO

  A non-zero winding rule for determining the interior of a path.

  See Also:
    Constant Field Values

Constructor Detail

### GeneralPath

    public GeneralPath()

  Constructs a new `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.

See Also:
  `WIND_NON_ZERO`

### GeneralPath

    public GeneralPath(int rule)

  Constructs a new `GeneralPath` object with the specified winding rule to control operations that require the interior of the path to be defined.

Parameters:
  `rule` - the winding rule
See Also:
  `WIND_EVEN_ODD`, `WIND_NON_ZERO`

### GeneralPath

    public GeneralPath(int rule,
                       int initialCapacity)

  Constructs a new `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.

Parameters:
  `rule` - the winding rule
  `initialCapacity` - the estimate for the number of path segments in the path
See Also:
  `WIND_EVEN_ODD`, `WIND_NON_ZERO`

### GeneralPath

    public GeneralPath(Shape s)

  Constructs a new `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.

Parameters:
  `s` - the specified `Shape` object

Method Detail

### moveTo

    public void moveTo(float x,
                       float y)

  Adds a point to the path by moving to the specified coordinates.

### lineTo

    public 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.

### quadTo

    public 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.

### curveTo

    public 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.

### closePath

    public void closePath()

  Closes the current subpath by drawing a straight line back to the coordinates of the last `moveTo`. If the path is already closed then this method has no effect.

### append

    public void append(Shape s,
                       boolean connect)

  Appends the geometry of the specified `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.

  Parameters:
    `s` - the `Shape` whose geometry is appended to this path
    `connect` - 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

### append

    public void append(PathIterator pi,
                       boolean connect)

  Appends the geometry of the specified `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.

  Parameters:
    `pi` - the `PathIterator` whose geometry is appended to this path
    `connect` - 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

### getWindingRule

    public int getWindingRule()

  Returns the fill style winding rule.

  Returns:
    an integer representing the current winding rule.
  See Also:
    `WIND_EVEN_ODD`, `WIND_NON_ZERO`, `setWindingRule(int)`

### setWindingRule

    public void setWindingRule(int rule)

  Sets the winding rule for this path to the specified value.

  Parameters:
    `rule` - an integer representing the specified winding rule
  Throws:
    ``IllegalArgumentException`` - if `rule` is not either `WIND_EVEN_ODD` or `WIND_NON_ZERO`
  See Also:
    `WIND_EVEN_ODD`, `WIND_NON_ZERO`, `getWindingRule()`

### getCurrentPoint

    public Point2D getCurrentPoint()

  Returns the coordinates most recently added to the end of the path as a `Point2D` object.

  Returns:
    a `Point2D` object containing the ending coordinates of the path or `null` if there are no points in the path.

### reset

    public void reset()

  Resets the path to empty. The append position is set back to the beginning of the path and all coordinates and point types are forgotten.

### transform

    public void transform(AffineTransform at)

  Transforms the geometry of this path using the specified `AffineTransform`. The geometry is transformed in place, which permanently changes the boundary defined by this object.

  Parameters:
    `at` - the `AffineTransform` used to transform the area

### createTransformedShape

    public Shape createTransformedShape(AffineTransform at)

  Returns a new transformed `Shape`.

  Parameters:
    `at` - the `AffineTransform` used to transform a new `Shape`.
  Returns:
    a new `Shape`, transformed with the specified `AffineTransform`.

### getBounds

    public Rectangle getBounds()

  Return the bounding box of the path.

  Specified by:
    `getBounds` in interface `Shape`
  Returns:
    a `Rectangle` object that bounds the current path.
  See Also:
    `Shape.getBounds2D()`

### getBounds2D

    public Rectangle2D getBounds2D()

  Returns the bounding box of the path.

  Specified by:
    `getBounds2D` in interface `Shape`
  Returns:
    a `Rectangle2D` object that bounds the current path.
  See Also:
    `Shape.getBounds()`

### contains

    public boolean contains(double x,
                            double y)

  Tests if the specified coordinates are inside the boundary of this `Shape`.

  Specified by:
    `contains` in interface `Shape`
  Returns:
    `true` if the specified coordinates are inside this `Shape`; `false` otherwise

### contains

    public boolean contains(Point2D p)

  Tests if the specified `Point2D` is inside the boundary of this `Shape`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `p` - the specified `Point2D`
  Returns:
    `true` if this `Shape` contains the specified `Point2D`, `false` otherwise.

### contains

    public boolean contains(double x,
                            double y,
                            double w,
                            double h)

  Tests if the specified rectangular area is inside the boundary of this `Shape`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `w` - the width of the specified rectangular area
    `h` - the height of the specified rectangular area
  Returns:
    `true` if this `Shape` contains the specified rectangluar area; `false` otherwise.
  See Also:
    `Area`, `Shape.intersects(double, double, double, double)`

### contains

    public boolean contains(Rectangle2D r)

  Tests if the specified `Rectangle2D` is inside the boundary of this `Shape`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `r` - a specified `Rectangle2D`
  Returns:
    `true` if this `Shape` bounds the specified `Rectangle2D`; `false` otherwise.
  See Also:
    `Shape.contains(double, double, double, double)`

### intersects

    public boolean intersects(double x,
                              double y,
                              double w,
                              double h)

  Tests if the interior of this `Shape` intersects the interior of a specified set of rectangular coordinates.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `w` - the width of the specified rectangular coordinates
    `h` - the height of the specified rectangular coordinates
  Returns:
    `true` if this `Shape` and the interior of the specified set of rectangular coordinates intersect each other; `false` otherwise.
  See Also:
    `Area`

### intersects

    public boolean intersects(Rectangle2D r)

  Tests if the interior of this `Shape` intersects the interior of a specified `Rectangle2D`.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `r` - the specified `Rectangle2D`
  Returns:
    `true` if this `Shape` and the interior of the specified `Rectangle2D` intersect each other; `false` otherwise.
  See Also:
    `Shape.intersects(double, double, double, double)`

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at)

  Returns a `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.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an `AffineTransform`
  Returns:
    a new `PathIterator` that iterates along the boundary of this `Shape` and provides access to the geometry of this `Shape`'s outline

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at,
                                        double flatness)

  Returns a `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.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an `AffineTransform`
    `flatness` - the maximum distance that the line segments used to approximate the curved segments are allowed to deviate from any point on the original curve
  Returns:
    a new `PathIterator` that iterates along the flattened `Shape` boundary.

### clone

    public Object clone()

  Creates a new object of the same class as this object.

  Overrides:
    `clone` in class `Object`
  Returns:
    a clone of this instance.
  Throws:
    `OutOfMemoryError` - if there is not enough memory.
  Since:
    1.2
  See Also:
    `Cloneable`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

JavaTM 2 Platform
Std. Ed. v1.4.1_"07"

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug or feature
For further API reference and developer documentation, see Java 2 SDK SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright 2002 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.