Path

Path

Path ()

Create an empty path

Path

Path (Path src)

Create a new path, copying the contents from the src path.

addArc

void addArc (float left, 
                float top, 
                float right, 
                float bottom, 
                float startAngle, 
                float sweepAngle)

Add the specified arc to the path as a new contour.

addArc

void addArc (RectF oval, 
                float startAngle, 
                float sweepAngle)

Add the specified arc to the path as a new contour.

addCircle

void addCircle (float x, 
                float y, 
                float radius, 
                Path.Direction dir)

Add a closed circle contour to the path

addOval

void addOval (RectF oval, 
                Path.Direction dir)

Add a closed oval contour to the path

addOval

void addOval (float left, 
                float top, 
                float right, 
                float bottom, 
                Path.Direction dir)

Add a closed oval contour to the path

addPath

void addPath (Path src, 
                Matrix matrix)

Add a copy of src to the path, transformed by matrix

addPath

void addPath (Path src)

Add a copy of src to the path

addPath

void addPath (Path src, 
                float dx, 
                float dy)

Add a copy of src to the path, offset by (dx,dy)

addRect

void addRect (RectF rect, 
                Path.Direction dir)

Add a closed rectangle contour to the path

addRect

void addRect (float left, 
                float top, 
                float right, 
                float bottom, 
                Path.Direction dir)

Add a closed rectangle contour to the path

addRoundRect

void addRoundRect (RectF rect, 
                float rx, 
                float ry, 
                Path.Direction dir)

Add a closed round-rectangle contour to the path

addRoundRect

void addRoundRect (float left, 
                float top, 
                float right, 
                float bottom, 
                float rx, 
                float ry, 
                Path.Direction dir)

Add a closed round-rectangle contour to the path

addRoundRect

void addRoundRect (RectF rect, 
                float[] radii, 
                Path.Direction dir)

Add a closed round-rectangle contour to the path. Each corner receives two radius values [X, Y]. The corners are ordered top-left, top-right, bottom-right, bottom-left

addRoundRect

void addRoundRect (float left, 
                float top, 
                float right, 
                float bottom, 
                float[] radii, 
                Path.Direction dir)

Add a closed round-rectangle contour to the path. Each corner receives two radius values [X, Y]. The corners are ordered top-left, top-right, bottom-right, bottom-left

arcTo

void arcTo (RectF oval, 
                float startAngle, 
                float sweepAngle, 
                boolean forceMoveTo)

Append the specified arc to the path as a new contour. If the start of the path is different from the path's current last point, then an automatic lineTo() is added to connect the current contour to the start of the arc. However, if the path is empty, then we call moveTo() with the first point of the arc.

arcTo

void arcTo (float left, 
                float top, 
                float right, 
                float bottom, 
                float startAngle, 
                float sweepAngle, 
                boolean forceMoveTo)

Append the specified arc to the path as a new contour. If the start of the path is different from the path's current last point, then an automatic lineTo() is added to connect the current contour to the start of the arc. However, if the path is empty, then we call moveTo() with the first point of the arc.

arcTo

void arcTo (RectF oval, 
                float startAngle, 
                float sweepAngle)

Append the specified arc to the path as a new contour. If the start of the path is different from the path's current last point, then an automatic lineTo() is added to connect the current contour to the start of the arc. However, if the path is empty, then we call moveTo() with the first point of the arc.

close

void close ()

Close the current contour. If the current point is not equal to the first point of the contour, a line segment is automatically added.

computeBounds

void computeBounds (RectF bounds, 
                boolean exact)

Compute the bounds of the control points of the path, and write the answer into bounds. If the path contains 0 or 1 points, the bounds is set to (0,0,0,0)

cubicTo

void cubicTo (float x1, 
                float y1, 
                float x2, 
                float y2, 
                float x3, 
                float y3)

Add a cubic bezier from the last point, approaching control points (x1,y1) and (x2,y2), and ending at (x3,y3). If no moveTo() call has been made for this contour, the first point is automatically set to (0,0).

getFillType

Path.FillType getFillType ()

Return the path's fill type. This defines how "inside" is computed. The default value is WINDING.

incReserve

void incReserve (int extraPtCount)

Hint to the path to prepare for adding more points. This can allow the path to more efficiently allocate its storage.

isConvex

boolean isConvex ()

Returns the path's convexity, as defined by the content of the path.

A path is convex if it has a single contour, and only ever curves in a single direction.

This function will calculate the convexity of the path from its control points, and cache the result.

isEmpty

boolean isEmpty ()

Returns true if the path is empty (contains no lines or curves)

isInverseFillType

boolean isInverseFillType ()

Returns true if the filltype is one of the INVERSE variants

isRect

boolean isRect (RectF rect)

Returns true if the path specifies a rectangle. If so, and if rect is not null, set rect to the bounds of the path. If the path does not specify a rectangle, return false and ignore rect.

lineTo

void lineTo (float x, 
                float y)

Add a line from the last point to the specified point (x,y). If no moveTo() call has been made for this contour, the first point is automatically set to (0,0).

moveTo

void moveTo (float x, 
                float y)

Set the beginning of the next contour to the point (x,y).

offset

void offset (float dx, 
                float dy, 
                Path dst)

Offset the path by (dx,dy)

offset

void offset (float dx, 
                float dy)

Offset the path by (dx,dy)

op

boolean op (Path path1, 
                Path path2, 
                Path.Op op)

Set this path to the result of applying the Op to the two specified paths. The resulting path will be constructed from non-overlapping contours. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.

op

boolean op (Path path, 
                Path.Op op)

Set this path to the result of applying the Op to this path and the specified path. The resulting path will be constructed from non-overlapping contours. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.

quadTo

void quadTo (float x1, 
                float y1, 
                float x2, 
                float y2)

Add a quadratic bezier from the last point, approaching control point (x1,y1), and ending at (x2,y2). If no moveTo() call has been made for this contour, the first point is automatically set to (0,0).

rCubicTo

void rCubicTo (float x1, 
                float y1, 
                float x2, 
                float y2, 
                float x3, 
                float y3)

Same as cubicTo, but the coordinates are considered relative to the current point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically.

rLineTo

void rLineTo (float dx, 
                float dy)

Same as lineTo, but the coordinates are considered relative to the last point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically.

rMoveTo

void rMoveTo (float dx, 
                float dy)

Set the beginning of the next contour relative to the last point on the previous contour. If there is no previous contour, this is treated the same as moveTo().

rQuadTo

void rQuadTo (float dx1, 
                float dy1, 
                float dx2, 
                float dy2)

Same as quadTo, but the coordinates are considered relative to the last point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically.

reset

void reset ()

Clear any lines and curves from the path, making it empty. This does NOT change the fill-type setting.

rewind

void rewind ()

Rewinds the path: clears any lines and curves from the path but keeps the internal data structure for faster reuse.

set

void set (Path src)

Replace the contents of this with the contents of src.

setFillType

void setFillType (Path.FillType ft)

Set the path's fill type. This defines how "inside" is computed.

setLastPoint

void setLastPoint (float dx, 
                float dy)

Sets the last point of the path.

toggleInverseFillType

void toggleInverseFillType ()

Toggles the INVERSE state of the filltype

transform

void transform (Matrix matrix, 
                Path dst)

Transform the points in this path by matrix, and write the answer into dst. If dst is null, then the the original path is modified.

transform

void transform (Matrix matrix)

Transform the points in this path by matrix.

finalize

void finalize ()

Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.

The general contract of finalize is that it is invoked if and when the Java^TM virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

The Java programming language does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java virtual machine for any given object.

Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.