fun createPattern(bitmap: Bitmap, cycleX: CycleMethod = CycleMethod.NO_CYCLE, cycleY: CycleMethod = cycleX, smooth: Boolean = true, transform: Matrix = Matrix.IDENTITY): BitmapPaint

createRadialGradient

inline fun createRadialGradient(x0: Number, y0: Number, r0: Number, x1: Number, y1: Number, r1: Number, cycle: CycleMethod = CycleMethod.NO_CYCLE, transform: Matrix = Matrix.IDENTITY, block: GradientPaint.() -> Unit = {}): GradientPaint

createSweepGradient

inline fun createSweepGradient(x0: Number, y0: Number, startAngle: Angle = Angle.ZERO, transform: Matrix = Matrix.IDENTITY, block: GradientPaint.() -> Unit = {}): GradientPaint

cubic

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

cubicTo

open override 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)

curve

open fun curve(curve: Bezier)

curves

open fun curves(curves: Curves)

open fun curves(curves: List<Curves>)

dispose

open override fun dispose()

draw

fun draw(d: Drawable)

open override fun draw(c: Context2d)

draw

fun Context2d.draw(path: VectorPath)

fun <T : Bitmap> Drawable.draw(out: T): T

drawImage

open fun drawImage(image: Bitmap, pos: Point, size: Size = image.size.toFloat())

drawRichText

fun Context2d.drawRichText(text: RichTextData, bounds: Rectangle = Rectangle(0, 0, width, height), wordWrap: Boolean = true, includePartialLines: Boolean = false, ellipsis: String? = null, fill: Paint? = null, stroke: Stroke? = null, align: TextAlignment = TextAlignment.TOP_LEFT, includeFirstLineAlways: Boolean = true, textRangeStart: Int = 0, textRangeEnd: Int = Int.MAX_VALUE): Int

drawShape

fun drawShape(shape: Drawable, rasterizerMethod: ShapeRasterizerMethod = ShapeRasterizerMethod.X4, native: Boolean = true)

drawText

fun <T> drawText(text: T, pos: Point = Point.ZERO, fill: Boolean = true, paint: Paint? = null, font: Font? = this.font, size: Double = this.fontSize, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = this.alignment, outMetrics: TextMetricsResult? = null, fillStyle: Paint? = null, stroke: Stroke? = null, textRangeStart: Int = 0, textRangeEnd: Int = Int.MAX_VALUE): TextMetricsResult?

ellipse

open fun ellipse(ellipse: Ellipse)

open fun ellipse(bounds: Rectangle)

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

fill

fun fill(winding: Winding? = null)

fun fill(paint: Paint?, winding: Winding? = null)

inline fun fill(paint: Paint, begin: Boolean = true, winding: Winding? = null, block: () -> Unit)

inline fun fill(color: RGBA, alpha: Double, begin: Boolean = true, winding: Winding? = null, block: () -> Unit)

fillRect

fun fillRect(x: Double, y: Double, width: Double, height: Double)

inline fun fillRect(x: Number, y: Number, width: Number, height: Number)

fillRoundRect

inline fun fillRoundRect(x: Number, y: Number, width: Number, height: Number, rx: Number, ry: Number = rx)

fillStroke

fun fillStroke()

inline fun fillStroke(fill: Paint?, stroke: Stroke?, callback: () -> Unit = {})

inline fun fillStroke(fill: Paint?, stroke: Paint?, strokeInfo: StrokeInfo? = null, callback: () -> Unit = {})

fillStyle

inline fun fillStyle(paint: Paint, callback: () -> Unit)

fillText

fun fillText(text: String, pos: Point)

inline fun fillText(text: String, pos: Point, font: Font? = this.font, size: Number = this.fontSize, align: TextAlignment = this.alignment, color: Paint? = null)

font

inline fun font(font: Font? = this.font, align: TextAlignment = this.alignment, size: Double = this.fontSize, callback: () -> Unit)

getBounds

fun getBounds(): Rectangle

getTextBounds

fun getTextBounds(text: String, out: TextMetrics = TextMetrics(), fontSize: Double = this.fontSize, renderer: TextRenderer<String> = DefaultStringTextRenderer, align: TextAlignment = this.alignment): TextMetrics

isEmpty

open fun isEmpty(): Boolean

isNotEmpty

open fun isNotEmpty(): Boolean

keep

inline fun keep(callback: () -> Unit)

keepApply

inline fun keepApply(callback: Context2d.() -> Unit): Context2d

keepTransform

inline fun keepTransform(callback: () -> Unit)

line

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

lineDash

inline fun lineDash(lineDash: DoubleList?, lineDashOffset: Double = 0.0, callback: () -> Unit)

lineTo

open override 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)

lineToH

open fun lineToH(x: Double)

lineToV

open fun lineToV(y: Double)

moveTo

open override 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)

moveToH

open fun moveToH(x: Double)

moveToV

open fun moveToV(y: Double)

parallelogram

open fun parallelogram(bounds: Rectangle, angle: Angle, direction: Boolean)

path

fun path(path: VectorPath)

pathSvg

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

polygon

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

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

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

polyline

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

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

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

quad

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

quadTo

open override 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)

rCubicTo

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

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

rect

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)

rectHole

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)

regularPolygon

open fun regularPolygon(points: Int, radius: Double, rotated: Angle, x: Double, y: Double)

regularPolygonHole

open fun regularPolygonHole(points: Int, radius: Double, rotated: Angle, x: Double, y: Double)

renderTo

fun Drawable.renderTo(ctx: Context2d)

renderToImage

fun Drawable.renderToImage(width: Int, height: Int): NativeImage

fun Drawable.renderToImage(width: Int, height: Int, native: Boolean): Bitmap

restore

fun restore()

rLineTo

open fun rLineTo(delta: Point)

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

rLineToH

open fun rLineToH(x: Double)

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

rLineToHV

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

rLineToV

open fun rLineToV(y: Double)

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

rMoveTo

open fun rMoveTo(delta: Point)

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

rMoveToH

open fun rMoveToH(x: Double)

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

rMoveToHV

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

rMoveToV

open fun rMoveToV(y: Double)

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

rotate

fun rotate(angle: Angle)

inline fun rotate(angle: Angle, block: () -> Unit)

roundRect

open fun roundRect(rect: RoundRectangle)

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

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

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

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

rQuadTo

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

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

save

fun save()

scale

fun scale(sx: Double, sy: Double = sx)

inline fun scale(sx: Int, sy: Int = sx)

inline fun scale(sx: Number, sy: Number = sx)

inline fun scale(sx: Number, sy: Number = sx, block: () -> Unit)

setTransform

fun setTransform(m: Matrix)

fun setTransform(a: Double, b: Double, c: Double, d: Double, tx: Double, ty: Double)

shear

fun shear(sx: Double, sy: Double)

skew

fun skew(skewX: Angle = 0.degrees, skewY: Angle = 0.degrees)

inline fun skew(skewX: Angle = Angle.ZERO, skewY: Angle = Angle.ZERO, block: () -> Unit)

star

open fun star(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle, x: Double, y: Double)

starHole

open fun starHole(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle, x: Double, y: Double)

stroke

fun stroke()

fun stroke(paint: Paint)

inline fun stroke(stroke: Stroke?, begin: Boolean = true, callback: () -> Unit = {})

inline fun stroke(paint: Paint?, info: StrokeInfo?, begin: Boolean = true, callback: () -> Unit = {})

inline fun stroke(paint: Paint, lineWidth: Number = this.lineWidth, lineCap: LineCap = this.lineCap, lineJoin: LineJoin = this.lineJoin, miterLimit: Number = this.miterLimit, lineDash: DoubleList? = this.lineDash, lineDashOffset: Number = this.lineDashOffset, begin: Boolean = true, callback: () -> Unit = {})

strokeDot

fun strokeDot(x: Double, y: Double)

strokeRect

fun strokeRect(x: Double, y: Double, width: Double, height: Double)

inline fun strokeRect(x: Number, y: Number, width: Number, height: Number)

strokeStyle

inline fun strokeStyle(paint: Paint, callback: () -> Unit)

strokeText

fun strokeText(text: String, pos: Point)

text

fun <T> VectorBuilder.text(text: T, font: VectorFont, textSize: Double = 16.0, pos: Point = Point.ZERO, align: TextAlignment = TextAlignment.BASELINE_LEFT, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>)

toShape