korge-core/korlibs.image.vector/Context2d

Context2d

open class Context2d(val renderer: Renderer, val defaultFontRegistry: FontRegistry? = null, val defaultFont: Font? = null) : VectorBuilder, Disposable

Inheritors

ShapeBuilder

Constructors

Context2d

constructor(renderer: Renderer, defaultFontRegistry: FontRegistry? = null, defaultFont: Font? = null)

Types

ScaledRenderer

class ScaledRenderer(val parent: Renderer, val scaleX: Float, val scaleY: Float) : Renderer

State

data class State(var transform: Matrix = Matrix.IDENTITY, var clip: VectorPath? = null, var path: VectorPath = VectorPath(), var lineScaleMode: LineScaleMode = LineScaleMode.NORMAL, var lineWidth: Double = 1.0, var startLineCap: LineCap = LineCap.BUTT, var endLineCap: LineCap = LineCap.BUTT, var lineJoin: LineJoin = LineJoin.MITER, var miterLimit: Double = 10.0, var strokeStyle: Paint = DefaultPaint, var fillStyle: Paint = DefaultPaint, var fontRegistry: FontRegistry? = null, var font: Font? = null, var fontSize: Double = 24.0, var verticalAlign: VerticalAlign = VerticalAlign.BASELINE, var horizontalAlign: HorizontalAlign = HorizontalAlign.LEFT, var globalAlpha: Double = 1.0, var globalCompositeOperation: CompositeOperation = CompositeMode.SOURCE_OVER, var lineDash: DoubleList? = null, var lineDashOffset: Double = 0.0)

Properties

alignment

var alignment: TextAlignment

debug

var debug: Boolean

defaultFont

val defaultFont: Font? = null

defaultFontRegistry

val defaultFontRegistry: FontRegistry? = null

endLineCap

var endLineCap: LineCap

fillStyle

var fillStyle: Paint

font

var font: Font?

fontName

var fontName: String?

fontRegistry

var fontRegistry: FontRegistry?

fontSize

var fontSize: Double

globalAlpha

var globalAlpha: Double

globalCompositeOperation

var globalCompositeOperation: CompositeOperation

height

open val height: Int

horizontalAlign

var horizontalAlign: HorizontalAlign

lastMovePos

open override var lastMovePos: Point

lastPos

open override var lastPos: Point

lineCap

var lineCap: LineCap

lineDash

var lineDash: DoubleList?

lineDashOffset

var lineDashOffset: Double

lineJoin

var lineJoin: LineJoin

lineScaleMode

var lineScaleMode: LineScaleMode

lineWidth

var lineWidth: Double

miterLimit

var miterLimit: Double

renderer

val renderer: Renderer

startLineCap

var startLineCap: LineCap

state

var state: Context2d.State

strokeStyle

var strokeStyle: Paint

totalPoints

open override val totalPoints: Int

verticalAlign

var verticalAlign: VerticalAlign

width

open val width: Int

Functions

arc

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

arcTo

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

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

arrow

fun Context2d.arrow(p0: Point, p1: Point, width: Double, paint: Paint, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

arrowCap

fun Context2d.arrowCap(p0: Point, p1: Point, width: Double, paint: Paint, cap: ArrowCap)

arrowTo

fun Context2d.arrowTo(p1: Point, width: Double, paint: Paint, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

beginPath

fun beginPath()

buffering

inline fun <T> buffering(callback: () -> T): T

cfCubicTo

fun VectorBuilder.cfCubicTo(fcx1: Double, fcy1: Double, fcx2: Double, fcy2: Double, fax: Double, fay: Double)

cfrClose

fun VectorBuilder.cfrClose()

cfrCubicTo

fun VectorBuilder.cfrCubicTo(cx1: Double, cy1: Double, cx2: Double, cy2: Double, ax: Double, ay: Double)

cfrLineTo

fun VectorBuilder.cfrLineTo(x: Double, y: Double)

cfrLineToHV

fun VectorBuilder.cfrLineToHV(v: Double, horizontal: Boolean)

cfrMoveTo

fun VectorBuilder.cfrMoveTo(x: Double, y: Double)

cfrMoveToHV

fun VectorBuilder.cfrMoveToHV(v: Double, horizontal: Boolean)

circle

open fun circle(circle: Circle)

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

circleHole

open fun circleHole(circle: Circle)

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

clip

fun clip(path: VectorPath? = state.path, winding: Winding = Winding.NON_ZERO)

fun clip(buildClipShape: () -> Unit, useClipShape: () -> Unit)

inline fun clip(path: VectorPath?, winding: Winding = Winding.NON_ZERO, block: () -> Unit)

inline fun clip(path: VectorPath.() -> Unit, winding: Winding = Winding.NON_ZERO, block: () -> Unit)

open override fun close()

createColor

fun createColor(color: RGBA): RGBA

createLinearGradient

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

createPattern

fun createPattern(bitmap: Bitmap, repeat: Boolean = false, smooth: Boolean = true, transform: Matrix = Matrix.IDENTITY): BitmapPaint

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)

draw

fun Context2d.draw(path: VectorPath)

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)

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

transform

fun transform(m: Matrix)