Path

fun combine(operation: PathOperation, path1: Path, path2: Path): Path

Combines the two paths according to the manner specified by the given operation.

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.

Throws IllegalArgumentException if the combining operation fails.

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

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.

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

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.

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

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.

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

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

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

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.

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

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

open infix fun and(path: Path): Path

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

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

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.

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

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.

fun close(): Unit

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

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

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

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)

open operator fun iterator(): PathIterator

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.

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

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

fun lineTo(x: Float, y: Float): Unit

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

open operator fun minus(path: Path): Path

Returns the difference of two paths as a new Path.

fun moveTo(x: Float, y: Float): Unit

Starts a new subpath at the given coordinate

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.

open infix fun or(path: Path): Path

Returns the union of two paths as a new Path.

open operator fun plus(path: Path): Path

Returns the union of two paths as a new Path.

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

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

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

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

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

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.

fun relativeLineTo(dx: Float, dy: Float): Unit

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

fun relativeMoveTo(dx: Float, dy: Float): Unit

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

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

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.

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

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.

fun reset(): Unit

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.

open fun rewind(): Unit

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

open fun transform(matrix: Matrix): Unit

Transform the points in this path by the provided matrix

fun translate(offset: Offset): Unit

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

open infix fun xor(path: Path): Path

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

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)

fun Path.addOutline(outline: Outline): Unit

Adds the outline to the Path.

fun Path.computeDirection(): Path.Direction

Computes this Path's direction (or winding, or orientation), which can be either Path.Direction.Clockwise or Path.Direction.CounterClockwise.

If the path is made of multiple contours (the path contains multiple "move" commands), the direction returned by this property is the direction of the first contour.

If the path is empty (contains no lines/curves), the direction is Path.Direction.Clockwise.

If the path has no area (single straight line), the direction is Path.Direction.Clockwise.

Calling this property does not cache the result, the direction is computed Calling this method does not cache the result, the direction is computed every time the method is called.

If you need to query the direction of individual contours, you should divide the path first.

fun Path.divide(contours: MutableList<Path> = mutableListOf()): MutableList<Path>

Divides this path into a list of paths. Each contour inside this path is returned as a separate Path. For instance the following code snippet creates two rectangular contours:

val p = Path()
p.addRect(...)
p.addRect(...)

val contours = p.divide()

The list returned by calling p.divide() will contain two Path instances, each representing one of the two rectangles.

Empty contours (contours with no lines/curves) are omitted from the resulting list.

fun Path.reverse(destination: Path = Path()): Path

Reverses the segments of this path into the specified destination, turning a clockwise path into a counter-clockwise path and vice-versa. Each contour in the path is reversed independently, and the contours appear in the destination in reverse order.

This method preserves the general structure of this path as much as possible:

• Lines become lines

• Quadratic Bézier curves become quadratic Bézier curves

• Cubic Bézier curves become cubic Bézier curves

• Close and move commands remain close and move commands

• Conic segments become quadratic Bézier curves

fun Path.copy(): Path

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

fun Path.addSvg(pathData: String): Unit

Adds the specified SVG path data to this Path. The SVG path data encodes a series of instructions that will be applied to this path. For instance, the following path data:

M200,300 Q400,50 600,300 L1000,300

Will generate the following series of instructions for this path:

moveTo(200f, 300f)
quadraticTo(400f, 50f, 600f, 300f)
lineTo(1000f, 300f)

To convert a Path to its SVG path data representation, please refer to Path.toSvg.

fun Path.toSvg(asDocument: Boolean = false): String

Returns an SVG representation of this path. The caller can choose whether the returned SVG represents a fully-formed SVG document or only the path data. By default, only the path data is returned which can be used either with Path.addSvg or androidx.compose.ui.graphics.vector.PathParser.