korge-foundation/korlibs.math.geom.vector/IVectorPath

IVectorPath

interface IVectorPath : VectorBuilder

Inheritors

Properties

abstract val lastMovePos: Point

abstract val lastPos: Point

abstract val totalPoints: Int

Functions

open override fun VectorBuilder.append(p0: Point, p1: Point, width: Double)

open fun arc(center: Point, r: Double, start: Angle, end: Angle, counterclockwise: Boolean = false)

open fun arcTo(a: Point, c: Point, r: Double)

open fun arcTo(a: Point, c: Point, r: Float)

fun VectorBuilder.arrow(p0: Point, p1: Point, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

fun VectorBuilder.arrowTo(p: Point, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

open fun circle(circle: Circle)

open fun circle(center: Point, radius: Double)

inline fun VectorBuilder.circle(center: Point, radius: Number)

open fun circleHole(circle: Circle)

open fun circleHole(center: Point, radius: Double)

inline fun VectorBuilder.circleHole(center: Point, radius: Number)

abstract fun close()

open fun cubic(o: Point, c1: Point, c2: Point, a: Point)

abstract fun cubicTo(c1: Point, c2: Point, a: Point)

open fun cubicTo(c1x: Double, c1y: Double, c2x: Double, c2y: Double, ax: Double, ay: Double)

open fun cubicTo(c1x: Float, c1y: Float, c2x: Float, c2y: Float, ax: Float, ay: Float)

open fun cubicTo(c1x: Int, c1y: Int, c2x: Int, c2y: Int, ax: Int, ay: Int)

fun VectorBuilder.cubicTo(c1: Point, c2: Point, a: Point, m: Matrix = Matrix.NIL)

open fun curve(curve: Bezier)

open fun curves(curves: Curves)

open fun curves(curves: List<Curves>)

open fun ellipse(ellipse: Ellipse)

open fun ellipse(bounds: Rectangle)

open fun ellipse(center: Point, radius: Size)

open fun isEmpty(): Boolean

open fun isNotEmpty(): Boolean

open fun line(p0: Point, p1: Point)

abstract fun lineTo(p: Point)

open fun lineTo(x: Double, y: Double)

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

open fun lineTo(x: Int, y: Int)

fun VectorBuilder.lineTo(p: Point, m: Matrix = Matrix.NIL)

open fun lineToH(x: Double)

open fun lineToV(y: Double)

abstract fun moveTo(p: Point)

open fun moveTo(x: Double, y: Double)

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

open fun moveTo(x: Int, y: Int)

fun VectorBuilder.moveTo(p: Point, m: Matrix = Matrix.NIL)

open fun moveToH(x: Double)

open fun moveToV(y: Double)

open fun parallelogram(bounds: Rectangle, angle: Angle = 30.degrees, direction: Boolean = true)

Creates a parallelogram where the inner part is within bounds.

fun VectorBuilder.path(path: VectorPath?)

fun VectorBuilder.path(path: VectorPath, m: Matrix = Matrix.NIL)

fun VectorBuilder.polyArrows(points: PointList, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

fun VectorBuilder.polyArrows(vararg points: Point, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

fun VectorBuilder.polyArrows(points: List<Point>, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

Creates a polyline from points adding arrow caps (capEnd and capStart) in each segment. Useful for displaying directed graphs

open fun polygon(path: PointList, close: Boolean = true)

open fun polygon(vararg path: Point, close: Boolean = true)

open fun polygon(path: List<Point>, close: Boolean = true)

open fun polyline(points: PointList, close: Boolean = false)

open fun polyline(vararg points: Point, close: Boolean = false)

open fun polyline(points: List<Point>, close: Boolean = false)

open fun quad(o: Point, c: Point, a: Point)

open fun quadTo(c: Point, a: Point)

open fun quadTo(cx: Double, cy: Double, ax: Double, ay: Double)

open fun quadTo(cx: Float, cy: Float, ax: Float, ay: Float)

open fun quadTo(cx: Int, cy: Int, ax: Int, ay: Int)

fun VectorBuilder.quadTo(c: Point, a: Point, m: Matrix = Matrix.NIL)

open fun rCubicTo(c1: Point, c2: Point, a: Point)

open fun rCubicTo(c1: Point, c2: Point, a: Point, relative: Boolean)

open fun rect(rect: Rectangle)

open fun rect(rect: RectangleInt)

open fun rect(pos: Point, size: Size)

open fun rect(x: Double, y: Double, width: Double, height: Double)

open fun rect(x: Float, y: Float, width: Float, height: Float)

open fun rect(x: Int, y: Int, width: Int, height: Int)

open fun rectHole(rect: Rectangle)

open fun rectHole(x: Double, y: Double, width: Double, height: Double)

open fun rectHole(x: Float, y: Float, width: Float, height: Float)

open fun rectHole(x: Int, y: Int, width: Int, height: Int)

open fun regularPolygon(points: Int, radius: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

regularPolygonHole

open fun regularPolygonHole(points: Int, radius: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

open fun rLineTo(delta: Point)

open fun rLineTo(a: Point, relative: Boolean)

open fun rLineToH(x: Double)

open fun rLineToH(x: Double, relative: Boolean)

open fun rLineToHV(value: Double, horizontal: Boolean)

open fun rLineToV(y: Double)

open fun rLineToV(y: Double, relative: Boolean)

open fun rMoveTo(delta: Point)

open fun rMoveTo(a: Point, relative: Boolean)

open fun rMoveToH(x: Double)

open fun rMoveToH(x: Double, relative: Boolean)

open fun rMoveToHV(value: Double, horizontal: Boolean)

open fun rMoveToV(y: Double)

open fun rMoveToV(y: Double, relative: Boolean)

open fun roundRect(rect: RoundRectangle)

open fun roundRect(x: Double, y: Double, w: Double, h: Double, rx: Double, ry: Double = rx)

open fun roundRect(x: Float, y: Float, w: Float, h: Float, rx: Float, ry: Float = rx)

open fun roundRect(x: Int, y: Int, w: Int, h: Int, rx: Int, ry: Int = rx)

open fun roundRect(x: Double, y: Double, w: Double, h: Double, rtl: Double, rtr: Double, rbr: Double, rbl: Double)

open fun rQuadTo(c: Point, a: Point)

open fun rQuadTo(c: Point, a: Point, relative: Boolean)

open fun star(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

open fun starHole(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

abstract fun toSvgString(): String

open fun transformed(m: Matrix): VectorBuilder

open fun <T> transformed(m: Matrix, block: VectorBuilder.() -> T): T

open fun write(curves: Curves)

open fun write(curves: List<Curves>)

fun VectorBuilder.write(path: VectorPath)

fun VectorBuilder.write(path: VectorPath, m: Matrix = Matrix.NIL)