Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

# Path

`interface Path`
 Known Direct Subclasses AndroidPath

## Summary

Public methods
abstract Unit
`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.

abstract Unit
`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.

abstract Unit
`addOval(oval: Rect)`

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

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

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

open Unit
`addRRect(rrect: RoundRect)`

Add a round rectangle shape to the path from the given RoundRect

abstract Unit
`addRect(rect: Rect)`

Adds a new subpath that consists of four lines that outline the given rectangle.

abstract Unit
`addRoundRect(roundRect: RoundRect)`

Add a round rectangle shape to the path from the given RoundRect

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

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

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

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

abstract Unit
`close()`

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

abstract Unit
`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).

abstract Rect
`getBounds()`

Compute the bounds of the control points of the path, and write the answer into bounds.

abstract Unit
`lineTo(x: Float, y: Float)`

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

abstract Unit
`moveTo(x: Float, y: Float)`

Starts a new subpath at the given coordinate

abstract Boolean
`op(path1: Path, path2: Path, operation: PathOperation)`

Set this path to the result of applying the Op to the two specified paths.

abstract Unit
`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).

abstract Unit
`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.

abstract Unit
`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.

abstract Unit
`relativeMoveTo(dx: Float, dy: Float)`

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

abstract Unit
`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.

abstract Unit
`reset()`

Clears the Path object of all subpaths, returning it to the same state it had when it was created.

abstract Unit
`shift(offset: Offset)`

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

Companion functions
Path
`combine(operation: PathOperation, path1: Path, path2: Path)`

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

Extension functions
From androidx.compose.ui.graphics
 Unit `Path.addOutline(outline: Outline)` Adds the outline to the Path. Path `Path.asAndroidPath()`
From androidx.ui.test
 Boolean `Path.contains(offset: Offset)` Tests to see if the given point is within the path.
Properties
abstract PathFillType
`fillType`

Determines how the interior of this path is calculated.

abstract Boolean
`isConvex`

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

abstract Boolean
`isEmpty`

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

## Public methods

`abstract 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.

`abstract 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.

`abstract fun addOval(oval: Rect): 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.

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

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

If `matrix4` is specified, the path will be transformed by this matrix after the matrix is translated by the given offset. The matrix is a 4x4 matrix stored in column major order.

`open fun addRRect(rrect: RoundRect): Unit`

Deprecated.

Add a round rectangle shape to the path from the given RoundRect

`abstract fun addRect(rect: Rect): Unit`

Adds a new subpath that consists of four lines that outline the given rectangle.

`abstract fun addRoundRect(roundRect: RoundRect): Unit`

Add a round rectangle shape to the path from the given RoundRect

### arcTo

`abstract 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.

### close

`abstract 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.

### cubicTo

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

### getBounds

`abstract 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)

### lineTo

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

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

### moveTo

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

Starts a new subpath at the given coordinate

### op

`abstract 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
path1: Path The first operand (for difference, the minuend)
path2: Path The second operand (for difference, the subtrahend)
Return
True if operation succeeded, false otherwise and this path remains unmodified.

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

### relativeCubicTo

`abstract 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.

### relativeLineTo

`abstract 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.

### relativeMoveTo

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

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

`abstract 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.

### reset

`abstract 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.

### shift

`abstract fun shift(offset: Offset): Unit`

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

## Properties

### fillType

`abstract var fillType: PathFillType`

Determines how the interior of this path is calculated.

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

### isConvex

`abstract 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.

### isEmpty

`abstract val isEmpty: Boolean`

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

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

## Companion functions

### combine

`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 as Android framework does not support this API