Path

@JvmDefaultWithCompatibility
/* expect class */ interface Path

Properties

var fillType: PathFillType

Determines how the interior of this path is calculated.

Defaults to the non-zero winding rule, PathFillType.NonZero.

val isConvex: Boolean

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.

val isEmpty: Boolean

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

Returns

Functions

moveTo

fun moveTo(x: Float, y: Float)

Starts a new subpath at the given coordinate

relativeMoveTo

fun relativeMoveTo(dx: Float, dy: Float)

Starts a new subpath at the given offset from the current point

lineTo

fun lineTo(x: Float, y: Float)

Adds a straight line segment from the current point to the given point

relativeLineTo

fun relativeLineTo(dx: Float, dy: Float)

Adds a straight line segment from the current point to the point at the given offset from the current point.

quadraticBezierTo

fun quadraticBezierTo(x1: Float, y1: Float, x2: Float, y2: Float)

Adds a quadratic bezier segment that curves from the current point to the given point (x2, y2), using the control point (x1, y1).

quadraticTo

fun quadraticTo(x1: Float, y1: Float, x2: Float, y2: Float)

Adds a quadratic bezier segment that curves from the current point to the given point (x2, y2), using the control point (x1, y1).

relativeQuadraticBezierTo

fun relativeQuadraticBezierTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float)

Adds a quadratic bezier segment that curves from the current point to the point at the offset (dx2, dy2) from the current point, using the control point at the offset (dx1, dy1) from the current point.

relativeQuadraticTo

fun relativeQuadraticTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float)

Adds a quadratic bezier segment that curves from the current point to the point at the offset (dx2, dy2) from the current point, using the control point at the offset (dx1, dy1) from the current point.

cubicTo

fun cubicTo(x1: Float, y1: Float, x2: Float, y2: Float, x3: Float, y3: Float)

Adds a cubic bezier segment that curves from the current point to the given point (x3, y3), using the control points (x1, y1) and (x2, y2).

relativeCubicTo

fun relativeCubicTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float, dx3: Float, dy3: Float)

Adds a cubic bezier segment that curves from the current point to the point at the offset (dx3, dy3) from the current point, using the control points at the offsets (dx1, dy1) and (dx2, dy2) from the current point.

arcToRad

fun arcToRad(
        rect: Rect,
        startAngleRadians: Float,
        sweepAngleRadians: Float,
        forceMoveTo: Boolean,
    )

If the forceMoveTo argument is false, adds a straight line segment and an arc segment.

If the forceMoveTo argument is true, starts a new subpath consisting of an arc segment.

In either case, the arc segment consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle radians around the oval up to startAngle + sweepAngle radians around the oval, with zero radians being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.

The line segment added if forceMoveTo is false starts at the current point and ends at the start of the arc.

arcTo

fun arcTo(rect: Rect, startAngleDegrees: Float, sweepAngleDegrees: Float, forceMoveTo: Boolean)

If the forceMoveTo argument is false, adds a straight line segment and an arc segment.

If the forceMoveTo argument is true, starts a new subpath consisting of an arc segment.

In either case, the arc segment consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle degrees around the oval up to startAngle + sweepAngle degrees around the oval, with zero degrees being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.

The line segment added if forceMoveTo is false starts at the current point and ends at the start of the arc.

addRect

fun addRect(rect: Rect)

Adds a new subpath that consists of four lines that outline the given rectangle. The rectangle is wound counter-clockwise.

addRect

fun addRect(rect: Rect, direction: Direction = Direction.CounterClockwise)

Adds a new subpath that consists of four lines that outline the given rectangle. The direction to wind the rectangle's contour is specified by direction.

addOval

fun addOval(oval: Rect)

Adds a new subpath that consists of a curve that forms the ellipse that fills the given rectangle.

To add a circle, pass an appropriate rectangle as oval. Rect can be used to easily describe the circle's center Offset and radius.

The oval is wound counter-clockwise.

addOval

fun addOval(oval: Rect, direction: Direction = Direction.CounterClockwise)

Adds a new subpath that consists of a curve that forms the ellipse that fills the given rectangle.

To add a circle, pass an appropriate rectangle as oval. Rect can be used to easily describe the circle's center Offset and radius.

The direction to wind the rectangle's contour is specified by direction.

addRoundRect

fun addRoundRect(roundRect: RoundRect)

Add a round rectangle shape to the path from the given RoundRect. The round rectangle is wound counter-clockwise.

addRoundRect

fun addRoundRect(roundRect: RoundRect, direction: Direction = Direction.CounterClockwise)

Add a round rectangle shape to the path from the given RoundRect. The direction to wind the rectangle's contour is specified by direction.

addArcRad

fun addArcRad(oval: Rect, startAngleRadians: Float, sweepAngleRadians: Float)

Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle radians around the oval up to startAngle + sweepAngle radians around the oval, with zero radians being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.

addArc

fun addArc(oval: Rect, startAngleDegrees: Float, sweepAngleDegrees: Float)

Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle degrees around the oval up to startAngle + sweepAngle degrees around the oval, with zero degrees being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.

addPath

fun addPath(path: Path, offset: Offset = Offset.Zero)

Adds a new subpath that consists of the given path offset by the given offset.

close

fun close()

Closes the last subpath, as if a straight line had been drawn from the current point to the first point of the subpath.

reset

fun reset()

Clears the Path object of all subpaths, returning it to the same state it had when it was created. The current point is reset to the origin. This does NOT change the fill-type setting.

rewind

fun rewind()

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

translate

fun translate(offset: Offset)

Translates all the segments of every subpath by the given offset.

transform

fun transform(matrix: Matrix)

Transform the points in this path by the provided matrix

getBounds

fun getBounds(): Rect

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)

iterator

operator fun iterator() = PathIterator(this)

Creates a new PathIterator for this Path that evaluates conics as quadratics. To preserve conics, use the Path.iterator function that takes a PathIterator.ConicEvaluation parameter.

iterator

fun iterator(conicEvaluation: PathIterator.ConicEvaluation, tolerance: Float = 0.25f) =
        PathIterator(this, conicEvaluation, tolerance)

Creates a new PathIterator for this Path. To preserve conics as conics (not convert them to quadratics), set conicEvaluation to PathIterator.ConicEvaluation.AsConic.

Parameters

op

fun op(path1: Path, path2: Path, operation: PathOperation): Boolean

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.

Parameters

Returns

plus

operator fun plus(path: Path) = Path().apply { op(this@Path, path, PathOperation.Union) }

Returns the union of two paths as a new Path.

minus

operator fun minus(path: Path) = Path().apply { op(this@Path, path, PathOperation.Difference) }

Returns the difference of two paths as a new Path.

or

infix fun or(path: Path): Path

Returns the union of two paths as a new Path.

and

infix fun and(path: Path) = Path().apply { op(this@Path, path, PathOperation.Intersect) }

Returns the intersection of two paths as a new Path. If the paths do not intersect, returns an empty path.

xor

infix fun xor(path: Path) = Path().apply { op(this@Path, path, PathOperation.Xor) }

Returns the union minus the intersection of two paths as a new Path.