CGPath

applyWithBlock

applyWithBlock(block: ((arg0: SDKHandle) => void)): void

func applyWithBlock(_ block: (UnsafePointer<CGPathElement>) -> Void)

copy

copy(): (CGPath) | null

func copy() -> CGPath?

copy

copyUsing(transform?: (SDKHandle) | null): (CGPath) | null

func copy(using transform: UnsafePointer<CGAffineTransform>?) -> CGPath?

mutableCopy

mutableCopy(): (CGMutablePath) | null

func mutableCopy() -> CGMutablePath?

mutableCopy

mutableCopyUsing(transform?: (SDKHandle) | null): (CGMutablePath) | null

func mutableCopy(using transform: UnsafePointer<CGAffineTransform>?) -> CGMutablePath?

init

static initEllipseInTransform(rect: { x: number; y: number; width: number; height: number }, transform?: (SDKHandle) | null): CGPath

init(ellipseIn rect: CGRect, transform: UnsafePointer<CGAffineTransform>?)

init

static initRectTransform(rect: { x: number; y: number; width: number; height: number }, transform?: (SDKHandle) | null): CGPath

init(rect: CGRect, transform: UnsafePointer<CGAffineTransform>?)

init

static initRoundedRectCornerWidthCornerHeightTransform(rect: { x: number; y: number; width: number; height: number }, cornerWidth: number, cornerHeight: number, transform?: (SDKHandle) | null): CGPath

init(roundedRect rect: CGRect, cornerWidth: CGFloat, cornerHeight: CGFloat, transform: UnsafePointer<CGAffineTransform>?)

boundingBox

get boundingBox(): { x: number; y: number; width: number; height: number }

var boundingBox: CGRect { get }

currentPoint

get currentPoint(): { x: number; y: number }

var currentPoint: CGPoint { get }

boundingBoxOfPath

get boundingBoxOfPath(): { x: number; y: number; width: number; height: number }

var boundingBoxOfPath: CGRect { get }

typeID

static get typeID(): number

class var typeID: CFTypeID { get }

isEmpty

get isEmpty(): boolean

var isEmpty: Bool { get }

isRect

isRect(rect?: ("animatableData" | SDKHandle) | null): boolean

func isRect(_ rect: UnsafeMutablePointer<CGRect>?) -> Bool

intersects

intersects(other: CGPath, rule?: CGPathFillRule): boolean

func intersects(_ other: CGPath, using rule: CGPathFillRule = .winding) -> Bool

Returns whether paths overlap. - Parameters: - other: The path to check for intersection. - rule: The rule for determining which areas to treat as the interior of the paths. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: `true` if the paths intersect. This is the same as testing if the intersection of two paths is not empty. That is, the filled areas of the paths overlap. Open subpaths are treated as closed subpaths, the same as when filling a path in a `CGContext`.

normalized

normalized(rule?: CGPathFillRule): CGPath

func normalized(using rule: CGPathFillRule = .winding) -> CGPath

Returns a new weakly-simple copy of this path. - Parameter rule: The rule for determining which areas to treat as the interior of the path. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The returned path is weakly-simple path, has no self-intersections, and has a normalized orientation. The result of filling this path using either even-odd or non-zero fill rules is identical.

subtracting

subtracting(other: CGPath, rule?: CGPathFillRule): CGPath

func subtracting(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with filled regions from this path that are not in the given path. - Parameters: - other: The path to subtract. - rule: The rule for determining which areas to treat as the interior of the paths. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The filled region of the resulting path is the filled region of this path with the filled region `other` removed from it. Any unclosed subpaths in either path are assumed to be closed. The result of filling this path using either even-odd or non-zero fill rules is identical.

intersection

intersection(other: CGPath, rule?: CGPathFillRule): CGPath

func intersection(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with filled regions common to both paths. - Parameters: - other: The path to intersect. - rule: The rule for determining which areas to treat as the interior of the paths. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The filled region of the resulting path is the overlapping area of the filled region of both paths. This can be used to clip the fill of a path to a mask. Any unclosed subpaths in either path are assumed to be closed. The result of filling this path using either even-odd or non-zero fill rules is identical.

lineSubtracting

lineSubtracting(other: CGPath, rule?: CGPathFillRule): CGPath

func lineSubtracting(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with a line from this path that does not overlap the filled region of the given path. - Parameters: - other: The path to subtract. - rule: The rule for determining which areas to treat as the interior of `other`. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The line of the resulting path is the line of this path that does not overlap the filled region of `other`. Intersected subpaths that are clipped create open subpaths. Closed subpaths that do not intersect `other` remain closed.

lineIntersection

lineIntersection(other: CGPath, rule?: CGPathFillRule): CGPath

func lineIntersection(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with a line from this path that overlaps the filled regions of the given path. - Parameters: - other: The path to intersect. - rule: The rule for determining which areas to treat as the interior of `other`. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The line of the resulting path is the line of this path that overlaps the filled region of `other`. Intersected subpaths that are clipped create open subpaths. Closed subpaths that do not intersect `other` remain closed.

componentsSeparated

componentsSeparated(rule?: CGPathFillRule): Array<CGPath>

func componentsSeparated(using rule: CGPathFillRule = .winding) -> [CGPath]

Return an array of the visually separated components of a path. - Parameter rule: The rule for determining which areas to treat as the interior of the path. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: The visually separate components. Separating components of a path returns the components from splitting the path into multiple distinct paths. Rendered individually the components look the same as the original path. This can be used to break a single path (eg. a symbol) into its component pieces so that each component can be colored separately.

symmetricDifference

symmetricDifference(other: CGPath, rule?: CGPathFillRule): CGPath

func symmetricDifference(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with filled regions either from this path or the given path, but not in both. - Parameters: - other: The path to difference. - rule: The rule for determining which areas to treat as the interior of the paths. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The filled region of the resulting path is the filled region contained in either this path or `other`, but not both. Any unclosed subpaths in either path are assumed to be closed. The result of filling this path using either even-odd or non-zero fill rules is identical.

copy

copyDashingWithPhaseLengthsTransform(phase: number, lengths: Array<number>, transform?: _CoreFoundation_CGAffineTransform): CGPath

func copy(dashingWithPhase phase: CGFloat, lengths: [CGFloat], transform: CGAffineTransform = .identity) -> CGPath

copy

copyStrokingWithWidthLineCapLineJoinMiterLimitTransform(lineWidth: number, lineCap: CGLineCap, lineJoin: CGLineJoin, miterLimit: number, transform?: _CoreFoundation_CGAffineTransform): CGPath

func copy(strokingWithWidth lineWidth: CGFloat, lineCap: CGLineCap, lineJoin: CGLineJoin, miterLimit: CGFloat, transform: CGAffineTransform = .identity) -> CGPath

union

union(other: CGPath, rule?: CGPathFillRule): CGPath

func union(_ other: CGPath, using rule: CGPathFillRule = .winding) -> CGPath

Returns a new path with filled regions in either this path or the given path. - Parameters: - other: The path to union. - rule: The rule for determining which areas to treat as the interior of the paths. Defaults to the `CGPathFillRule.winding` rule if not specified. - Returns: A new path. The filled region of resulting path is the combination of the filled region of both paths added together. Any unclosed subpaths in either path are assumed to be closed. The result of filling this path using either even-odd or non-zero fill rules is identical.

contains

contains(point: { x: number; y: number }, rule?: CGPathFillRule, transform?: _CoreFoundation_CGAffineTransform): boolean

func contains(_ point: CGPoint, using rule: CGPathFillRule = .winding, transform: CGAffineTransform = .identity) -> Bool

flattened

flattened(threshold: number): CGPath

func flattened(threshold: CGFloat) -> CGPath

Returns a flattened copy of this path. - Parameter threshold: The maximum error tolerance. - Returns: A new path. The granularity of the approximation is controlled by `threshold` the maximum error tolerance (measured in points) for curves.