treeform
GitHub
commit
da6f96221e
4 changed files with 2594 additions and 0 deletions
237
bindings/bindings.nim
Normal file
237
bindings/bindings.nim
Normal file
|
|
@ -0,0 +1,237 @@
|
|||
import bindy, pixie, unicode
|
||||
|
||||
type
|
||||
Vector2 = object
|
||||
x*, y*: float32
|
||||
|
||||
Matrix3 = object
|
||||
a*, b*, c*, d*, e*, f*, g*, h*, i*: float32
|
||||
|
||||
var lastError*: ref PixieError
|
||||
|
||||
proc takeError*(): string =
|
||||
result = lastError.msg
|
||||
lastError = nil
|
||||
|
||||
proc checkError*(): bool =
|
||||
result = lastError != nil
|
||||
|
||||
proc drawImage1*(
|
||||
ctx: Context, image: Image, dx, dy: float32
|
||||
) {.raises: [PixieError].} =
|
||||
ctx.drawImage(image, dx, dy)
|
||||
|
||||
proc drawImage2*(
|
||||
ctx: Context, image: Image, dx, dy, dWidth, dHeight: float32
|
||||
) {.raises: [PixieError].} =
|
||||
ctx.drawImage(image, dx, dy, dWidth, dHeight)
|
||||
|
||||
proc drawImage3*(
|
||||
ctx: Context,
|
||||
image: Image,
|
||||
sx, sy, sWidth, sHeight,
|
||||
dx, dy, dWidth, dHeight: float32
|
||||
) {.raises: [PixieError].} =
|
||||
ctx.drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight)
|
||||
|
||||
exportEnums:
|
||||
export
|
||||
FileFormat,
|
||||
BlendMode,
|
||||
PaintKind,
|
||||
WindingRule,
|
||||
LineCap,
|
||||
LineJoin,
|
||||
HorizontalAlignment,
|
||||
VerticalAlignment,
|
||||
TextCase
|
||||
|
||||
exportObjects:
|
||||
export
|
||||
Vector2,
|
||||
Matrix3,
|
||||
Rect,
|
||||
Color,
|
||||
ColorStop,
|
||||
TextMetrics
|
||||
|
||||
exportProcs:
|
||||
export
|
||||
bindings.checkError,
|
||||
bindings.takeError
|
||||
|
||||
exportSeq seq[float32]:
|
||||
discard
|
||||
|
||||
exportSeq seq[Span]:
|
||||
export
|
||||
pixie.typeset,
|
||||
pixie.computeBounds
|
||||
|
||||
exportRefObject Image, ["width", "height"]:
|
||||
export
|
||||
pixie.writeFile,
|
||||
pixie.wh,
|
||||
pixie.copy,
|
||||
pixie.getColor,
|
||||
pixie.setColor,
|
||||
pixie.fill,
|
||||
pixie.flipHorizontal,
|
||||
pixie.flipVertical,
|
||||
pixie.subImage,
|
||||
pixie.minifyBy2,
|
||||
pixie.magnifyBy2,
|
||||
pixie.applyOpacity,
|
||||
pixie.invert,
|
||||
pixie.blur,
|
||||
pixie.newMask,
|
||||
pixie.resize,
|
||||
pixie.shadow,
|
||||
pixie.superImage,
|
||||
pixie.draw,
|
||||
pixie.fillGradient,
|
||||
pixie.fillText,
|
||||
pixie.strokeText,
|
||||
pixie.fillPath,
|
||||
pixie.strokePath,
|
||||
pixie.newContext
|
||||
|
||||
exportRefObject Mask, ["width", "height"]:
|
||||
export
|
||||
pixie.writeFile,
|
||||
pixie.wh,
|
||||
pixie.copy,
|
||||
pixie.getValue,
|
||||
pixie.setValue,
|
||||
pixie.fill,
|
||||
pixie.minifyBy2,
|
||||
pixie.spread,
|
||||
pixie.ceil,
|
||||
pixie.newImage,
|
||||
pixie.applyOpacity,
|
||||
pixie.invert,
|
||||
pixie.blur,
|
||||
pixie.draw,
|
||||
pixie.fillText,
|
||||
pixie.strokeText,
|
||||
pixie.fillPath,
|
||||
pixie.strokePath
|
||||
|
||||
exportRefObject Paint, ["*"]:
|
||||
export
|
||||
pixie.newPaint
|
||||
|
||||
exportRefObject Path, ["*"]:
|
||||
export
|
||||
pixie.transform,
|
||||
pixie.addPath,
|
||||
pixie.closePath,
|
||||
pixie.computeBounds,
|
||||
pixie.fillOverlaps,
|
||||
pixie.strokeOverlaps
|
||||
|
||||
toggleBasicOnly()
|
||||
|
||||
export
|
||||
pixie.moveTo,
|
||||
pixie.lineTo,
|
||||
pixie.bezierCurveTo,
|
||||
pixie.quadraticCurveTo,
|
||||
pixie.ellipticalArcTo,
|
||||
pixie.arc,
|
||||
pixie.arcTo,
|
||||
pixie.rect,
|
||||
pixie.roundedRect,
|
||||
pixie.ellipse,
|
||||
pixie.circle,
|
||||
pixie.polygon
|
||||
|
||||
exportRefObject Typeface, ["*"]:
|
||||
export
|
||||
pixie.ascent,
|
||||
pixie.descent,
|
||||
pixie.lineGap,
|
||||
pixie.lineHeight,
|
||||
pixie.getGlyphPath,
|
||||
pixie.getAdvance,
|
||||
pixie.getKerningAdjustment,
|
||||
pixie.newFont
|
||||
|
||||
exportRefObject Font, ["*"]:
|
||||
export
|
||||
pixie.scale,
|
||||
pixie.defaultLineHeight,
|
||||
pixie.typeset,
|
||||
pixie.computeBounds
|
||||
|
||||
exportRefObject Span, ["*"]:
|
||||
discard
|
||||
|
||||
exportRefObject Arrangement, []:
|
||||
export
|
||||
pixie.computeBounds
|
||||
|
||||
exportRefObject Context, ["*"]:
|
||||
export
|
||||
pixie.save,
|
||||
pixie.saveLayer,
|
||||
pixie.restore,
|
||||
pixie.beginPath,
|
||||
pixie.closePath,
|
||||
pixie.fill,
|
||||
pixie.clip,
|
||||
pixie.stroke,
|
||||
pixie.measureText,
|
||||
pixie.getTransform,
|
||||
pixie.setTransform,
|
||||
pixie.transform,
|
||||
pixie.resetTransform,
|
||||
bindings.drawImage1,
|
||||
bindings.drawImage2,
|
||||
bindings.drawImage3
|
||||
|
||||
toggleBasicOnly()
|
||||
|
||||
export
|
||||
pixie.moveTo,
|
||||
pixie.lineTo,
|
||||
pixie.bezierCurveTo,
|
||||
pixie.quadraticCurveTo,
|
||||
pixie.ellipticalArcTo,
|
||||
pixie.arc,
|
||||
pixie.arcTo,
|
||||
pixie.rect,
|
||||
pixie.roundedRect,
|
||||
pixie.ellipse,
|
||||
pixie.circle,
|
||||
pixie.polygon,
|
||||
pixie.clearRect,
|
||||
pixie.fillRect,
|
||||
pixie.strokeRect,
|
||||
pixie.fillText,
|
||||
pixie.strokeText,
|
||||
pixie.translate,
|
||||
pixie.scale,
|
||||
pixie.rotate,
|
||||
pixie.isPointInPath,
|
||||
pixie.isPointInStroke
|
||||
|
||||
exportProcs:
|
||||
export
|
||||
pixie.newImage,
|
||||
pixie.newMask,
|
||||
pixie.newPaint,
|
||||
pixie.newPath,
|
||||
pixie.newSpan,
|
||||
pixie.newContext,
|
||||
pixie.readImage,
|
||||
pixie.readmask,
|
||||
pixie.readTypeface,
|
||||
pixie.readFont,
|
||||
pixie.parsePath,
|
||||
pixie.miterLimitToAngle,
|
||||
pixie.angleToMiterLimit
|
||||
|
||||
writeFiles("bindings/generated", "pixie")
|
||||
|
||||
include generated/internal
|
||||
960
bindings/generated/internal.nim
Normal file
960
bindings/generated/internal.nim
Normal file
|
|
@ -0,0 +1,960 @@
|
|||
proc pixie_check_error*(): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
checkError()
|
||||
|
||||
proc pixie_take_error*(): cstring {.raises: [], cdecl, exportc, dynlib.} =
|
||||
takeError().cstring
|
||||
|
||||
type SeqFloat32* = ref object
|
||||
s: seq[float32]
|
||||
|
||||
proc pixie_new_seq_float32*(): SeqFloat32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
SeqFloat32()
|
||||
|
||||
proc pixie_seq_float32_len*(s: SeqFloat32): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.len
|
||||
|
||||
proc pixie_seq_float32_add*(s: SeqFloat32, v: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.add(v)
|
||||
|
||||
proc pixie_seq_float32_get*(s: SeqFloat32, i: int): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s[i]
|
||||
|
||||
proc pixie_seq_float32_set*(s: SeqFloat32, i: int, v: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s[i] = v
|
||||
|
||||
proc pixie_seq_float32_remove*(s: SeqFloat32, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.delete(i)
|
||||
|
||||
proc pixie_seq_float32_clear*(s: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.setLen(0)
|
||||
|
||||
proc pixie_seq_float32_unref*(s: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(s)
|
||||
|
||||
type SeqSpan* = ref object
|
||||
s: seq[Span]
|
||||
|
||||
proc pixie_new_seq_span*(): SeqSpan {.raises: [], cdecl, exportc, dynlib.} =
|
||||
SeqSpan()
|
||||
|
||||
proc pixie_seq_span_len*(s: SeqSpan): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.len
|
||||
|
||||
proc pixie_seq_span_add*(s: SeqSpan, v: Span) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.add(v)
|
||||
|
||||
proc pixie_seq_span_get*(s: SeqSpan, i: int): Span {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s[i]
|
||||
|
||||
proc pixie_seq_span_set*(s: SeqSpan, i: int, v: Span) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s[i] = v
|
||||
|
||||
proc pixie_seq_span_remove*(s: SeqSpan, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.delete(i)
|
||||
|
||||
proc pixie_seq_span_clear*(s: SeqSpan) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
s.s.setLen(0)
|
||||
|
||||
proc pixie_seq_span_unref*(s: SeqSpan) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(s)
|
||||
|
||||
proc pixie_seq_span_typeset*(spans: SeqSpan, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, wrap: bool): Arrangement {.raises: [], cdecl, exportc, dynlib.} =
|
||||
typeset(spans.s, bounds, h_align, v_align, wrap)
|
||||
|
||||
proc pixie_seq_span_compute_bounds*(spans: SeqSpan): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
computeBounds(spans.s)
|
||||
|
||||
proc pixie_image_unref*(x: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_image_get_width*(image: Image): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
image.width
|
||||
|
||||
proc pixie_image_set_width*(image: Image, width: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
image.width = width
|
||||
|
||||
proc pixie_image_get_height*(image: Image): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
image.height
|
||||
|
||||
proc pixie_image_set_height*(image: Image, height: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
image.height = height
|
||||
|
||||
proc pixie_image_write_file*(image: Image, file_path: cstring) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
writeFile(image, file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_wh*(image: Image): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
wh(image)
|
||||
|
||||
proc pixie_image_copy*(image: Image): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = copy(image)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_get_color*(image: Image, x: int, y: int): Color {.raises: [], cdecl, exportc, dynlib.} =
|
||||
getColor(image, x, y)
|
||||
|
||||
proc pixie_image_set_color*(image: Image, x: int, y: int, color: Color) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
setColor(image, x, y, color)
|
||||
|
||||
proc pixie_image_fill*(image: Image, color: Color) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
fill(image, color)
|
||||
|
||||
proc pixie_image_flip_horizontal*(image: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
flipHorizontal(image)
|
||||
|
||||
proc pixie_image_flip_vertical*(image: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
flipVertical(image)
|
||||
|
||||
proc pixie_image_sub_image*(image: Image, x: int, y: int, w: int, h: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = subImage(image, x, y, w, h)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_minify_by2*(image: Image, power: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = minifyBy2(image, power)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_magnify_by2*(image: Image, power: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = magnifyBy2(image, power)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_apply_opacity*(target: Image, opacity: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
applyOpacity(target, opacity)
|
||||
|
||||
proc pixie_image_invert*(target: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
invert(target)
|
||||
|
||||
proc pixie_image_blur*(image: Image, radius: float32, out_of_bounds: Color) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
blur(image, radius, out_of_bounds)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_new_mask*(image: Image): Mask {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = newMask(image)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_resize*(src_image: Image, width: int, height: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = resize(src_image, width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_shadow*(image: Image, offset: Vec2, spread: float32, blur: float32, color: Color): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = shadow(image, offset, spread, blur, color)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_super_image*(image: Image, x: int, y: int, w: int, h: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = superImage(image, x, y, w, h)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_mask_draw*(image: Image, mask: Mask, transform: Mat3, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
draw(image, mask, transform, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_image_draw*(a: Image, b: Image, transform: Mat3, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
draw(a, b, transform, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_fill_gradient*(image: Image, paint: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillGradient(image, paint)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_arrangement_fill_text*(target: Image, arrangement: Arrangement, transform: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillText(target, arrangement, transform)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_font_fill_text*(target: Image, font: Font, text: cstring, transform: Mat3, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillText(target, font, text.`$`, transform, bounds, h_align, v_align)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_arrangement_stroke_text*(target: Image, arrangement: Arrangement, transform: Mat3, stroke_width: float32, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeText(target, arrangement, transform, stroke_width, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_font_stroke_text*(target: Image, font: Font, text: cstring, transform: Mat3, stroke_width: float32, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeText(target, font, text.`$`, transform, stroke_width, bounds, h_align, v_align, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_fill_path*(image: Image, path: Path, paint: Paint, transform: Mat3, winding_rule: WindingRule) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillPath(image, path, paint, transform, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_stroke_path*(image: Image, path: Path, paint: Paint, transform: Mat3, stroke_width: float32, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokePath(image, path, paint, transform, stroke_width, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_image_new_context*(image: Image): Context {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newContext(image)
|
||||
|
||||
proc pixie_mask_unref*(x: Mask) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_mask_get_width*(mask: Mask): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
mask.width
|
||||
|
||||
proc pixie_mask_set_width*(mask: Mask, width: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
mask.width = width
|
||||
|
||||
proc pixie_mask_get_height*(mask: Mask): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
mask.height
|
||||
|
||||
proc pixie_mask_set_height*(mask: Mask, height: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
mask.height = height
|
||||
|
||||
proc pixie_mask_write_file*(mask: Mask, file_path: cstring) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
writeFile(mask, file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_wh*(mask: Mask): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
wh(mask)
|
||||
|
||||
proc pixie_mask_copy*(mask: Mask): Mask {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = copy(mask)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_get_value*(mask: Mask, x: int, y: int): uint8 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
getValue(mask, x, y)
|
||||
|
||||
proc pixie_mask_set_value*(mask: Mask, x: int, y: int, value: uint8) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
setValue(mask, x, y, value)
|
||||
|
||||
proc pixie_mask_fill*(mask: Mask, value: uint8) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
fill(mask, value)
|
||||
|
||||
proc pixie_mask_minify_by2*(mask: Mask, power: int): Mask {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = minifyBy2(mask, power)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_spread*(mask: Mask, spread: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
spread(mask, spread)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_ceil*(mask: Mask) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
ceil(mask)
|
||||
|
||||
proc pixie_mask_new_image*(mask: Mask): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = newImage(mask)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_apply_opacity*(target: Mask, opacity: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
applyOpacity(target, opacity)
|
||||
|
||||
proc pixie_mask_invert*(target: Mask) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
invert(target)
|
||||
|
||||
proc pixie_mask_blur*(mask: Mask, radius: float32, out_of_bounds: uint8) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
blur(mask, radius, out_of_bounds)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_mask_draw*(a: Mask, b: Mask, transform: Mat3, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
draw(a, b, transform, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_image_draw*(mask: Mask, image: Image, transform: Mat3, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
draw(mask, image, transform, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_arrangement_fill_text*(target: Mask, arrangement: Arrangement, transform: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillText(target, arrangement, transform)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_font_fill_text*(target: Mask, font: Font, text: cstring, transform: Mat3, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillText(target, font, text.`$`, transform, bounds, h_align, v_align)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_arrangement_stroke_text*(target: Mask, arrangement: Arrangement, transform: Mat3, stroke_width: float32, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeText(target, arrangement, transform, stroke_width, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_font_stroke_text*(target: Mask, font: Font, text: cstring, transform: Mat3, stroke_width: float32, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeText(target, font, text.`$`, transform, stroke_width, bounds, h_align, v_align, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_fill_path*(mask: Mask, path: Path, transform: Mat3, winding_rule: WindingRule, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillPath(mask, path, transform, winding_rule, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_mask_stroke_path*(mask: Mask, path: Path, transform: Mat3, stroke_width: float32, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32, blend_mode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokePath(mask, path, transform, stroke_width, line_cap, line_join, miter_limit, dashes.s, blend_mode)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_paint_unref*(x: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_paint_get_kind*(paint: Paint): PaintKind {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.kind
|
||||
|
||||
proc pixie_paint_set_kind*(paint: Paint, kind: PaintKind) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.kind = kind
|
||||
|
||||
proc pixie_paint_get_blend_mode*(paint: Paint): BlendMode {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.blendMode
|
||||
|
||||
proc pixie_paint_set_blend_mode*(paint: Paint, blendMode: BlendMode) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.blendMode = blendMode
|
||||
|
||||
proc pixie_paint_get_opacity*(paint: Paint): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.opacity
|
||||
|
||||
proc pixie_paint_set_opacity*(paint: Paint, opacity: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.opacity = opacity
|
||||
|
||||
proc pixie_paint_get_color*(paint: Paint): Color {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.color
|
||||
|
||||
proc pixie_paint_set_color*(paint: Paint, color: Color) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.color = color
|
||||
|
||||
proc pixie_paint_get_image*(paint: Paint): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.image
|
||||
|
||||
proc pixie_paint_set_image*(paint: Paint, image: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.image = image
|
||||
|
||||
proc pixie_paint_get_image_mat*(paint: Paint): Mat3 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.imageMat
|
||||
|
||||
proc pixie_paint_set_image_mat*(paint: Paint, imageMat: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.imageMat = imageMat
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_len*(paint: Paint): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions.len
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_add*(paint: Paint, v: Vec2) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions.add(v)
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_get*(paint: Paint, i: int): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions[i]
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_set*(paint: Paint, i: int, v: Vec2) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions[i] = v
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_remove*(paint: Paint, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions.delete(i)
|
||||
|
||||
proc pixie_paint_gradient_handle_positions_clear*(paint: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientHandlePositions.setLen(0)
|
||||
|
||||
proc pixie_paint_gradient_stops_len*(paint: Paint): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops.len
|
||||
|
||||
proc pixie_paint_gradient_stops_add*(paint: Paint, v: ColorStop) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops.add(v)
|
||||
|
||||
proc pixie_paint_gradient_stops_get*(paint: Paint, i: int): ColorStop {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops[i]
|
||||
|
||||
proc pixie_paint_gradient_stops_set*(paint: Paint, i: int, v: ColorStop) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops[i] = v
|
||||
|
||||
proc pixie_paint_gradient_stops_remove*(paint: Paint, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops.delete(i)
|
||||
|
||||
proc pixie_paint_gradient_stops_clear*(paint: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
paint.gradientStops.setLen(0)
|
||||
|
||||
proc pixie_paint_new_paint*(paint: Paint): Paint {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newPaint(paint)
|
||||
|
||||
proc pixie_path_unref*(x: Path) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_path_transform*(path: Path, mat: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
transform(path, mat)
|
||||
|
||||
proc pixie_path_add_path*(path: Path, other: Path) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
addPath(path, other)
|
||||
|
||||
proc pixie_path_close_path*(path: Path) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
closePath(path)
|
||||
|
||||
proc pixie_path_compute_bounds*(path: Path, transform: Mat3): Rect {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = computeBounds(path, transform)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_path_fill_overlaps*(path: Path, test: Vec2, transform: Mat3, winding_rule: WindingRule): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = fillOverlaps(path, test, transform, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_path_stroke_overlaps*(path: Path, test: Vec2, transform: Mat3, stroke_width: float32, line_cap: LineCap, line_join: LineJoin, miter_limit: float32, dashes: SeqFloat32): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = strokeOverlaps(path, test, transform, stroke_width, line_cap, line_join, miter_limit, dashes.s)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_path_move_to*(path: Path, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
moveTo(path, x, y)
|
||||
|
||||
proc pixie_path_line_to*(path: Path, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
lineTo(path, x, y)
|
||||
|
||||
proc pixie_path_bezier_curve_to*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, x3: float32, y3: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
bezierCurveTo(path, x1, y1, x2, y2, x3, y3)
|
||||
|
||||
proc pixie_path_quadratic_curve_to*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
quadraticCurveTo(path, x1, y1, x2, y2)
|
||||
|
||||
proc pixie_path_elliptical_arc_to*(path: Path, rx: float32, ry: float32, x_axis_rotation: float32, large_arc_flag: bool, sweep_flag: bool, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
ellipticalArcTo(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y)
|
||||
|
||||
proc pixie_path_arc*(path: Path, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
arc(path, x, y, r, a0, a1, ccw)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_path_arc_to*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, r: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
arcTo(path, x1, y1, x2, y2, r)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_path_rect*(path: Path, x: float32, y: float32, w: float32, h: float32, clockwise: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
rect(path, x, y, w, h, clockwise)
|
||||
|
||||
proc pixie_path_rounded_rect*(path: Path, x: float32, y: float32, w: float32, h: float32, nw: float32, ne: float32, se: float32, sw: float32, clockwise: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
roundedRect(path, x, y, w, h, nw, ne, se, sw, clockwise)
|
||||
|
||||
proc pixie_path_ellipse*(path: Path, cx: float32, cy: float32, rx: float32, ry: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
ellipse(path, cx, cy, rx, ry)
|
||||
|
||||
proc pixie_path_circle*(path: Path, cx: float32, cy: float32, r: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
circle(path, cx, cy, r)
|
||||
|
||||
proc pixie_path_polygon*(path: Path, x: float32, y: float32, size: float32, sides: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
polygon(path, x, y, size, sides)
|
||||
|
||||
proc pixie_typeface_unref*(x: Typeface) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_typeface_get_file_path*(typeface: Typeface): cstring {.raises: [], cdecl, exportc, dynlib.} =
|
||||
typeface.filePath.cstring
|
||||
|
||||
proc pixie_typeface_set_file_path*(typeface: Typeface, filePath: cstring) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
typeface.filePath = filePath.`$`
|
||||
|
||||
proc pixie_typeface_ascent*(typeface: Typeface): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
ascent(typeface)
|
||||
|
||||
proc pixie_typeface_descent*(typeface: Typeface): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
descent(typeface)
|
||||
|
||||
proc pixie_typeface_line_gap*(typeface: Typeface): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
lineGap(typeface)
|
||||
|
||||
proc pixie_typeface_line_height*(typeface: Typeface): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
lineHeight(typeface)
|
||||
|
||||
proc pixie_typeface_get_glyph_path*(typeface: Typeface, rune: int32): Path {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = getGlyphPath(typeface, rune.Rune)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_typeface_get_advance*(typeface: Typeface, rune: int32): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
getAdvance(typeface, rune.Rune)
|
||||
|
||||
proc pixie_typeface_get_kerning_adjustment*(typeface: Typeface, left: int32, right: int32): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
getKerningAdjustment(typeface, left.Rune, right.Rune)
|
||||
|
||||
proc pixie_typeface_new_font*(typeface: Typeface): Font {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newFont(typeface)
|
||||
|
||||
proc pixie_font_unref*(x: Font) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_font_get_typeface*(font: Font): Typeface {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.typeface
|
||||
|
||||
proc pixie_font_set_typeface*(font: Font, typeface: Typeface) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.typeface = typeface
|
||||
|
||||
proc pixie_font_get_size*(font: Font): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.size
|
||||
|
||||
proc pixie_font_set_size*(font: Font, size: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.size = size
|
||||
|
||||
proc pixie_font_get_line_height*(font: Font): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.lineHeight
|
||||
|
||||
proc pixie_font_set_line_height*(font: Font, lineHeight: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.lineHeight = lineHeight
|
||||
|
||||
proc pixie_font_paints_len*(font: Font): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints.len
|
||||
|
||||
proc pixie_font_paints_add*(font: Font, v: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints.add(v)
|
||||
|
||||
proc pixie_font_paints_get*(font: Font, i: int): Paint {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints[i]
|
||||
|
||||
proc pixie_font_paints_set*(font: Font, i: int, v: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints[i] = v
|
||||
|
||||
proc pixie_font_paints_remove*(font: Font, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints.delete(i)
|
||||
|
||||
proc pixie_font_paints_clear*(font: Font) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.paints.setLen(0)
|
||||
|
||||
proc pixie_font_get_text_case*(font: Font): TextCase {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.textCase
|
||||
|
||||
proc pixie_font_set_text_case*(font: Font, textCase: TextCase) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.textCase = textCase
|
||||
|
||||
proc pixie_font_get_underline*(font: Font): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.underline
|
||||
|
||||
proc pixie_font_set_underline*(font: Font, underline: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.underline = underline
|
||||
|
||||
proc pixie_font_get_strikethrough*(font: Font): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.strikethrough
|
||||
|
||||
proc pixie_font_set_strikethrough*(font: Font, strikethrough: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.strikethrough = strikethrough
|
||||
|
||||
proc pixie_font_get_no_kerning_adjustments*(font: Font): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.noKerningAdjustments
|
||||
|
||||
proc pixie_font_set_no_kerning_adjustments*(font: Font, noKerningAdjustments: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
font.noKerningAdjustments = noKerningAdjustments
|
||||
|
||||
proc pixie_font_scale*(font: Font): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
scale(font)
|
||||
|
||||
proc pixie_font_default_line_height*(font: Font): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
defaultLineHeight(font)
|
||||
|
||||
proc pixie_font_typeset*(font: Font, text: cstring, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, wrap: bool): Arrangement {.raises: [], cdecl, exportc, dynlib.} =
|
||||
typeset(font, text.`$`, bounds, h_align, v_align, wrap)
|
||||
|
||||
proc pixie_font_compute_bounds*(font: Font, text: cstring): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
computeBounds(font, text.`$`)
|
||||
|
||||
proc pixie_span_unref*(x: Span) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_span_get_text*(span: Span): cstring {.raises: [], cdecl, exportc, dynlib.} =
|
||||
span.text.cstring
|
||||
|
||||
proc pixie_span_set_text*(span: Span, text: cstring) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
span.text = text.`$`
|
||||
|
||||
proc pixie_span_get_font*(span: Span): Font {.raises: [], cdecl, exportc, dynlib.} =
|
||||
span.font
|
||||
|
||||
proc pixie_span_set_font*(span: Span, font: Font) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
span.font = font
|
||||
|
||||
proc pixie_arrangement_unref*(x: Arrangement) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_arrangement_compute_bounds*(arrangement: Arrangement): Vec2 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
computeBounds(arrangement)
|
||||
|
||||
proc pixie_context_unref*(x: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
GC_unref(x)
|
||||
|
||||
proc pixie_context_get_image*(context: Context): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.image
|
||||
|
||||
proc pixie_context_set_image*(context: Context, image: Image) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.image = image
|
||||
|
||||
proc pixie_context_get_fill_style*(context: Context): Paint {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.fillStyle
|
||||
|
||||
proc pixie_context_set_fill_style*(context: Context, fillStyle: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.fillStyle = fillStyle
|
||||
|
||||
proc pixie_context_get_stroke_style*(context: Context): Paint {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.strokeStyle
|
||||
|
||||
proc pixie_context_set_stroke_style*(context: Context, strokeStyle: Paint) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.strokeStyle = strokeStyle
|
||||
|
||||
proc pixie_context_get_global_alpha*(context: Context): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.globalAlpha
|
||||
|
||||
proc pixie_context_set_global_alpha*(context: Context, globalAlpha: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.globalAlpha = globalAlpha
|
||||
|
||||
proc pixie_context_get_line_width*(context: Context): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineWidth
|
||||
|
||||
proc pixie_context_set_line_width*(context: Context, lineWidth: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineWidth = lineWidth
|
||||
|
||||
proc pixie_context_get_miter_limit*(context: Context): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.miterLimit
|
||||
|
||||
proc pixie_context_set_miter_limit*(context: Context, miterLimit: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.miterLimit = miterLimit
|
||||
|
||||
proc pixie_context_get_line_cap*(context: Context): LineCap {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineCap
|
||||
|
||||
proc pixie_context_set_line_cap*(context: Context, lineCap: LineCap) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineCap = lineCap
|
||||
|
||||
proc pixie_context_get_line_join*(context: Context): LineJoin {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineJoin
|
||||
|
||||
proc pixie_context_set_line_join*(context: Context, lineJoin: LineJoin) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineJoin = lineJoin
|
||||
|
||||
proc pixie_context_get_font*(context: Context): cstring {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.font.cstring
|
||||
|
||||
proc pixie_context_set_font*(context: Context, font: cstring) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.font = font.`$`
|
||||
|
||||
proc pixie_context_get_font_size*(context: Context): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.fontSize
|
||||
|
||||
proc pixie_context_set_font_size*(context: Context, fontSize: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.fontSize = fontSize
|
||||
|
||||
proc pixie_context_get_text_align*(context: Context): HorizontalAlignment {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.textAlign
|
||||
|
||||
proc pixie_context_set_text_align*(context: Context, textAlign: HorizontalAlignment) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.textAlign = textAlign
|
||||
|
||||
proc pixie_context_line_dash_len*(context: Context): int {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash.len
|
||||
|
||||
proc pixie_context_line_dash_add*(context: Context, v: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash.add(v)
|
||||
|
||||
proc pixie_context_line_dash_get*(context: Context, i: int): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash[i]
|
||||
|
||||
proc pixie_context_line_dash_set*(context: Context, i: int, v: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash[i] = v
|
||||
|
||||
proc pixie_context_line_dash_remove*(context: Context, i: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash.delete(i)
|
||||
|
||||
proc pixie_context_line_dash_clear*(context: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
context.lineDash.setLen(0)
|
||||
|
||||
proc pixie_context_save*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
save(ctx)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_save_layer*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
saveLayer(ctx)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_restore*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
restore(ctx)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_begin_path*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
beginPath(ctx)
|
||||
|
||||
proc pixie_context_close_path*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
closePath(ctx)
|
||||
|
||||
proc pixie_context_path_fill*(ctx: Context, path: Path, winding_rule: WindingRule) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fill(ctx, path, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_winding_rule_fill*(ctx: Context, winding_rule: WindingRule) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fill(ctx, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_path_clip*(ctx: Context, path: Path, winding_rule: WindingRule) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
clip(ctx, path, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_winding_rule_clip*(ctx: Context, winding_rule: WindingRule) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
clip(ctx, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_path_stroke*(ctx: Context, path: Path) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
stroke(ctx, path)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_stroke*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
stroke(ctx)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_measure_text*(ctx: Context, text: cstring): TextMetrics {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = measureText(ctx, text.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_get_transform*(ctx: Context): Mat3 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
getTransform(ctx)
|
||||
|
||||
proc pixie_context_set_transform*(ctx: Context, transform: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
setTransform(ctx, transform)
|
||||
|
||||
proc pixie_context_transform*(ctx: Context, transform: Mat3) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
transform(ctx, transform)
|
||||
|
||||
proc pixie_context_reset_transform*(ctx: Context) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
resetTransform(ctx)
|
||||
|
||||
proc pixie_context_draw_image1*(ctx: Context, image: Image, dx: float32, dy: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
drawImage1(ctx, image, dx, dy)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_draw_image2*(ctx: Context, image: Image, dx: float32, dy: float32, d_width: float32, d_height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
drawImage2(ctx, image, dx, dy, d_width, d_height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_draw_image3*(ctx: Context, image: Image, sx: float32, sy: float32, s_width: float32, s_height: float32, dx: float32, dy: float32, d_width: float32, d_height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
drawImage3(ctx, image, sx, sy, s_width, s_height, dx, dy, d_width, d_height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_move_to*(ctx: Context, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
moveTo(ctx, x, y)
|
||||
|
||||
proc pixie_context_line_to*(ctx: Context, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
lineTo(ctx, x, y)
|
||||
|
||||
proc pixie_context_bezier_curve_to*(ctx: Context, cp1x: float32, cp1y: float32, cp2x: float32, cp2y: float32, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
bezierCurveTo(ctx, cp1x, cp1y, cp2x, cp2y, x, y)
|
||||
|
||||
proc pixie_context_quadratic_curve_to*(ctx: Context, cpx: float32, cpy: float32, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
quadraticCurveTo(ctx, cpx, cpy, x, y)
|
||||
|
||||
proc pixie_context_arc*(ctx: Context, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
arc(ctx, x, y, r, a0, a1, ccw)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_arc_to*(ctx: Context, x1: float32, y1: float32, x2: float32, y2: float32, radius: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
arcTo(ctx, x1, y1, x2, y2, radius)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_rect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
rect(ctx, x, y, width, height)
|
||||
|
||||
proc pixie_context_rounded_rect*(ctx: Context, x: float32, y: float32, w: float32, h: float32, nw: float32, ne: float32, se: float32, sw: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
roundedRect(ctx, x, y, w, h, nw, ne, se, sw)
|
||||
|
||||
proc pixie_context_ellipse*(ctx: Context, x: float32, y: float32, rx: float32, ry: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
ellipse(ctx, x, y, rx, ry)
|
||||
|
||||
proc pixie_context_circle*(ctx: Context, cx: float32, cy: float32, r: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
circle(ctx, cx, cy, r)
|
||||
|
||||
proc pixie_context_polygon*(ctx: Context, x: float32, y: float32, size: float32, sides: int) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
polygon(ctx, x, y, size, sides)
|
||||
|
||||
proc pixie_context_clear_rect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
clearRect(ctx, x, y, width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_fill_rect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillRect(ctx, x, y, width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_stroke_rect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeRect(ctx, x, y, width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_fill_text*(ctx: Context, text: cstring, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
fillText(ctx, text.`$`, x, y)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_stroke_text*(ctx: Context, text: cstring, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
strokeText(ctx, text.`$`, x, y)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_translate*(ctx: Context, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
translate(ctx, x, y)
|
||||
|
||||
proc pixie_context_scale*(ctx: Context, x: float32, y: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
scale(ctx, x, y)
|
||||
|
||||
proc pixie_context_rotate*(ctx: Context, angle: float32) {.raises: [], cdecl, exportc, dynlib.} =
|
||||
rotate(ctx, angle)
|
||||
|
||||
proc pixie_context_is_point_in_path*(ctx: Context, x: float32, y: float32, winding_rule: WindingRule): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = isPointInPath(ctx, x, y, winding_rule)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_context_is_point_in_stroke*(ctx: Context, x: float32, y: float32): bool {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = isPointInStroke(ctx, x, y)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_new_image*(width: int, height: int): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = newImage(width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_new_mask*(width: int, height: int): Mask {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = newMask(width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_new_paint*(kind: PaintKind): Paint {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newPaint(kind)
|
||||
|
||||
proc pixie_new_path*(): Path {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newPath()
|
||||
|
||||
proc pixie_new_span*(text: cstring, font: Font): Span {.raises: [], cdecl, exportc, dynlib.} =
|
||||
newSpan(text.`$`, font)
|
||||
|
||||
proc pixie_new_context*(width: int, height: int): Context {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = newContext(width, height)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_read_image*(file_path: cstring): Image {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = readImage(file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_read_mask*(file_path: cstring): Mask {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = readMask(file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_read_typeface*(file_path: cstring): Typeface {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = readTypeface(file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_read_font*(file_path: cstring): Font {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = readFont(file_path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_parse_path*(path: cstring): Path {.raises: [], cdecl, exportc, dynlib.} =
|
||||
try:
|
||||
result = parsePath(path.`$`)
|
||||
except PixieError as e:
|
||||
lastError = e
|
||||
|
||||
proc pixie_miter_limit_to_angle*(limit: float32): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
miterLimitToAngle(limit)
|
||||
|
||||
proc pixie_angle_to_miter_limit*(angle: float32): float32 {.raises: [], cdecl, exportc, dynlib.} =
|
||||
angleToMiterLimit(angle)
|
||||
|
||||
1394
bindings/generated/pixie.nim
Normal file
1394
bindings/generated/pixie.nim
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -15,3 +15,6 @@ requires "bumpy >= 1.0.3"
|
|||
|
||||
task docs, "Generate API documents":
|
||||
exec "nim doc --index:on --project --out:docs --hints:off src/pixie.nim"
|
||||
|
||||
task bindings, "Generate bindings":
|
||||
exec "nim c -f -d:release --app:lib --gc:arc --tlsEmulation:off --out:pixie --outdir:bindings/generated bindings/bindings.nim"
|
||||
|
|
|
|||
Loading…
Reference in a new issue