From 7a276ea50eb1cdfd866283b8e1f0f50e098a5f34 Mon Sep 17 00:00:00 2001 From: Ryan Oldenburg Date: Tue, 24 Aug 2021 22:19:28 -0500 Subject: [PATCH] add nim bindings --- bindings/bindings.nim | 2 +- bindings/generated/pixie.nim | 1395 ++++++++++++++++++++++++++++++++++ 2 files changed, 1396 insertions(+), 1 deletion(-) create mode 100644 bindings/generated/pixie.nim diff --git a/bindings/bindings.nim b/bindings/bindings.nim index 257d385..561786c 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -234,4 +234,4 @@ exportProcs: writeFiles("bindings/generated", "pixie") -include generated/dllapi +include generated/internal diff --git a/bindings/generated/pixie.nim b/bindings/generated/pixie.nim new file mode 100644 index 0000000..0f6b70b --- /dev/null +++ b/bindings/generated/pixie.nim @@ -0,0 +1,1395 @@ +import bumpy, chroma, unicode, vmath + +export bumpy, chroma, unicode, vmath + +{.push dynlib: "pixie.dll".} + +type PixieError = object of ValueError + +type FileFormat* = enum + ffPng + ffBmp + ffJpg + ffGif + +type BlendMode* = enum + bmNormal + bmDarken + bmMultiply + bmColorBurn + bmLighten + bmScreen + bmColorDodge + bmOverlay + bmSoftLight + bmHardLight + bmDifference + bmExclusion + bmHue + bmSaturation + bmColor + bmLuminosity + bmMask + bmOverwrite + bmSubtractMask + bmExcludeMask + +type PaintKind* = enum + pkSolid + pkImage + pkImageTiled + pkGradientLinear + pkGradientRadial + pkGradientAngular + +type WindingRule* = enum + wrNonZero + wrEvenOdd + +type LineCap* = enum + lcButt + lcRound + lcSquare + +type LineJoin* = enum + ljMiter + ljRound + ljBevel + +type HorizontalAlignment* = enum + haLeft + haCenter + haRight + +type VerticalAlignment* = enum + vaTop + vaMiddle + vaBottom + +type TextCase* = enum + tcNormal + tcUpper + tcLower + tcTitle + +type Rect* = object + x*: float32 + y*: float32 + w*: float32 + h*: float32 + +type ColorStop* = object + color*: Color + position*: float32 + +type TextMetrics* = object + width*: float32 + +type SeqFloat32* = object + reference: pointer + +proc pixie_seq_float32_unref*(x: SeqFloat32) {.importc: "pixie_seq_float32_unref", cdecl.} + +proc `=destroy`(x: var SeqFloat32) = + pixie_seq_float32_unref(x) + +type SeqSpan* = object + reference: pointer + +proc pixie_seq_span_unref*(x: SeqSpan) {.importc: "pixie_seq_span_unref", cdecl.} + +proc `=destroy`(x: var SeqSpan) = + pixie_seq_span_unref(x) + +type Image* = object + reference: pointer + +proc pixie_image_unref*(x: Image) {.importc: "pixie_image_unref", cdecl.} + +proc `=destroy`(x: var Image) = + pixie_image_unref(x) + +proc pixie_image_get_width(image: Image): int {.importc: "pixie_image_get_width", cdecl.} + +proc width*(image: Image): int {.inline.} = + pixie_image_get_width(image) + +proc pixie_image_set_width(image: Image, width: int) {.importc: "pixie_image_set_width", cdecl.} + +proc `width=`*(image: Image, width: int) = + pixie_image_set_width(image, width) + +proc pixie_image_get_height(image: Image): int {.importc: "pixie_image_get_height", cdecl.} + +proc height*(image: Image): int {.inline.} = + pixie_image_get_height(image) + +proc pixie_image_set_height(image: Image, height: int) {.importc: "pixie_image_set_height", cdecl.} + +proc `height=`*(image: Image, height: int) = + pixie_image_set_height(image, height) + +type Mask* = object + reference: pointer + +proc pixie_mask_unref*(x: Mask) {.importc: "pixie_mask_unref", cdecl.} + +proc `=destroy`(x: var Mask) = + pixie_mask_unref(x) + +proc pixie_mask_get_width(mask: Mask): int {.importc: "pixie_mask_get_width", cdecl.} + +proc width*(mask: Mask): int {.inline.} = + pixie_mask_get_width(mask) + +proc pixie_mask_set_width(mask: Mask, width: int) {.importc: "pixie_mask_set_width", cdecl.} + +proc `width=`*(mask: Mask, width: int) = + pixie_mask_set_width(mask, width) + +proc pixie_mask_get_height(mask: Mask): int {.importc: "pixie_mask_get_height", cdecl.} + +proc height*(mask: Mask): int {.inline.} = + pixie_mask_get_height(mask) + +proc pixie_mask_set_height(mask: Mask, height: int) {.importc: "pixie_mask_set_height", cdecl.} + +proc `height=`*(mask: Mask, height: int) = + pixie_mask_set_height(mask, height) + +type Paint* = object + reference: pointer + +proc pixie_paint_unref*(x: Paint) {.importc: "pixie_paint_unref", cdecl.} + +proc `=destroy`(x: var Paint) = + pixie_paint_unref(x) + +proc pixie_paint_get_kind(paint: Paint): PaintKind {.importc: "pixie_paint_get_kind", cdecl.} + +proc kind*(paint: Paint): PaintKind {.inline.} = + pixie_paint_get_kind(paint) + +proc pixie_paint_set_kind(paint: Paint, kind: PaintKind) {.importc: "pixie_paint_set_kind", cdecl.} + +proc `kind=`*(paint: Paint, kind: PaintKind) = + pixie_paint_set_kind(paint, kind) + +proc pixie_paint_get_blend_mode(paint: Paint): BlendMode {.importc: "pixie_paint_get_blend_mode", cdecl.} + +proc blendMode*(paint: Paint): BlendMode {.inline.} = + pixie_paint_get_blend_mode(paint) + +proc pixie_paint_set_blend_mode(paint: Paint, blendMode: BlendMode) {.importc: "pixie_paint_set_blend_mode", cdecl.} + +proc `blendMode=`*(paint: Paint, blendMode: BlendMode) = + pixie_paint_set_blend_mode(paint, blendMode) + +proc pixie_paint_get_opacity(paint: Paint): float32 {.importc: "pixie_paint_get_opacity", cdecl.} + +proc opacity*(paint: Paint): float32 {.inline.} = + pixie_paint_get_opacity(paint) + +proc pixie_paint_set_opacity(paint: Paint, opacity: float32) {.importc: "pixie_paint_set_opacity", cdecl.} + +proc `opacity=`*(paint: Paint, opacity: float32) = + pixie_paint_set_opacity(paint, opacity) + +proc pixie_paint_get_color(paint: Paint): Color {.importc: "pixie_paint_get_color", cdecl.} + +proc color*(paint: Paint): Color {.inline.} = + pixie_paint_get_color(paint) + +proc pixie_paint_set_color(paint: Paint, color: Color) {.importc: "pixie_paint_set_color", cdecl.} + +proc `color=`*(paint: Paint, color: Color) = + pixie_paint_set_color(paint, color) + +proc pixie_paint_get_image(paint: Paint): Image {.importc: "pixie_paint_get_image", cdecl.} + +proc image*(paint: Paint): Image {.inline.} = + pixie_paint_get_image(paint) + +proc pixie_paint_set_image(paint: Paint, image: Image) {.importc: "pixie_paint_set_image", cdecl.} + +proc `image=`*(paint: Paint, image: Image) = + pixie_paint_set_image(paint, image) + +proc pixie_paint_get_image_mat(paint: Paint): Mat3 {.importc: "pixie_paint_get_image_mat", cdecl.} + +proc imageMat*(paint: Paint): Mat3 {.inline.} = + pixie_paint_get_image_mat(paint) + +proc pixie_paint_set_image_mat(paint: Paint, imageMat: Mat3) {.importc: "pixie_paint_set_image_mat", cdecl.} + +proc `imageMat=`*(paint: Paint, imageMat: Mat3) = + pixie_paint_set_image_mat(paint, imageMat) + +type Path* = object + reference: pointer + +proc pixie_path_unref*(x: Path) {.importc: "pixie_path_unref", cdecl.} + +proc `=destroy`(x: var Path) = + pixie_path_unref(x) + +type Typeface* = object + reference: pointer + +proc pixie_typeface_unref*(x: Typeface) {.importc: "pixie_typeface_unref", cdecl.} + +proc `=destroy`(x: var Typeface) = + pixie_typeface_unref(x) + +proc pixie_typeface_get_file_path(typeface: Typeface): cstring {.importc: "pixie_typeface_get_file_path", cdecl.} + +proc filePath*(typeface: Typeface): cstring {.inline.} = + pixie_typeface_get_file_path(typeface).`$` + +proc pixie_typeface_set_file_path(typeface: Typeface, filePath: cstring) {.importc: "pixie_typeface_set_file_path", cdecl.} + +proc `filePath=`*(typeface: Typeface, filePath: string) = + pixie_typeface_set_file_path(typeface, filePath.cstring) + +type Font* = object + reference: pointer + +proc pixie_font_unref*(x: Font) {.importc: "pixie_font_unref", cdecl.} + +proc `=destroy`(x: var Font) = + pixie_font_unref(x) + +proc pixie_font_get_typeface(font: Font): Typeface {.importc: "pixie_font_get_typeface", cdecl.} + +proc typeface*(font: Font): Typeface {.inline.} = + pixie_font_get_typeface(font) + +proc pixie_font_set_typeface(font: Font, typeface: Typeface) {.importc: "pixie_font_set_typeface", cdecl.} + +proc `typeface=`*(font: Font, typeface: Typeface) = + pixie_font_set_typeface(font, typeface) + +proc pixie_font_get_size(font: Font): float32 {.importc: "pixie_font_get_size", cdecl.} + +proc size*(font: Font): float32 {.inline.} = + pixie_font_get_size(font) + +proc pixie_font_set_size(font: Font, size: float32) {.importc: "pixie_font_set_size", cdecl.} + +proc `size=`*(font: Font, size: float32) = + pixie_font_set_size(font, size) + +proc pixie_font_get_line_height(font: Font): float32 {.importc: "pixie_font_get_line_height", cdecl.} + +proc lineHeight*(font: Font): float32 {.inline.} = + pixie_font_get_line_height(font) + +proc pixie_font_set_line_height(font: Font, lineHeight: float32) {.importc: "pixie_font_set_line_height", cdecl.} + +proc `lineHeight=`*(font: Font, lineHeight: float32) = + pixie_font_set_line_height(font, lineHeight) + +proc pixie_font_get_text_case(font: Font): TextCase {.importc: "pixie_font_get_text_case", cdecl.} + +proc textCase*(font: Font): TextCase {.inline.} = + pixie_font_get_text_case(font) + +proc pixie_font_set_text_case(font: Font, textCase: TextCase) {.importc: "pixie_font_set_text_case", cdecl.} + +proc `textCase=`*(font: Font, textCase: TextCase) = + pixie_font_set_text_case(font, textCase) + +proc pixie_font_get_underline(font: Font): bool {.importc: "pixie_font_get_underline", cdecl.} + +proc underline*(font: Font): bool {.inline.} = + pixie_font_get_underline(font) + +proc pixie_font_set_underline(font: Font, underline: bool) {.importc: "pixie_font_set_underline", cdecl.} + +proc `underline=`*(font: Font, underline: bool) = + pixie_font_set_underline(font, underline) + +proc pixie_font_get_strikethrough(font: Font): bool {.importc: "pixie_font_get_strikethrough", cdecl.} + +proc strikethrough*(font: Font): bool {.inline.} = + pixie_font_get_strikethrough(font) + +proc pixie_font_set_strikethrough(font: Font, strikethrough: bool) {.importc: "pixie_font_set_strikethrough", cdecl.} + +proc `strikethrough=`*(font: Font, strikethrough: bool) = + pixie_font_set_strikethrough(font, strikethrough) + +proc pixie_font_get_no_kerning_adjustments(font: Font): bool {.importc: "pixie_font_get_no_kerning_adjustments", cdecl.} + +proc noKerningAdjustments*(font: Font): bool {.inline.} = + pixie_font_get_no_kerning_adjustments(font) + +proc pixie_font_set_no_kerning_adjustments(font: Font, noKerningAdjustments: bool) {.importc: "pixie_font_set_no_kerning_adjustments", cdecl.} + +proc `noKerningAdjustments=`*(font: Font, noKerningAdjustments: bool) = + pixie_font_set_no_kerning_adjustments(font, noKerningAdjustments) + +type Span* = object + reference: pointer + +proc pixie_span_unref*(x: Span) {.importc: "pixie_span_unref", cdecl.} + +proc `=destroy`(x: var Span) = + pixie_span_unref(x) + +proc pixie_span_get_text(span: Span): cstring {.importc: "pixie_span_get_text", cdecl.} + +proc text*(span: Span): cstring {.inline.} = + pixie_span_get_text(span).`$` + +proc pixie_span_set_text(span: Span, text: cstring) {.importc: "pixie_span_set_text", cdecl.} + +proc `text=`*(span: Span, text: string) = + pixie_span_set_text(span, text.cstring) + +proc pixie_span_get_font(span: Span): Font {.importc: "pixie_span_get_font", cdecl.} + +proc font*(span: Span): Font {.inline.} = + pixie_span_get_font(span) + +proc pixie_span_set_font(span: Span, font: Font) {.importc: "pixie_span_set_font", cdecl.} + +proc `font=`*(span: Span, font: Font) = + pixie_span_set_font(span, font) + +type Arrangement* = object + reference: pointer + +proc pixie_arrangement_unref*(x: Arrangement) {.importc: "pixie_arrangement_unref", cdecl.} + +proc `=destroy`(x: var Arrangement) = + pixie_arrangement_unref(x) + +type Context* = object + reference: pointer + +proc pixie_context_unref*(x: Context) {.importc: "pixie_context_unref", cdecl.} + +proc `=destroy`(x: var Context) = + pixie_context_unref(x) + +proc pixie_context_get_image(context: Context): Image {.importc: "pixie_context_get_image", cdecl.} + +proc image*(context: Context): Image {.inline.} = + pixie_context_get_image(context) + +proc pixie_context_set_image(context: Context, image: Image) {.importc: "pixie_context_set_image", cdecl.} + +proc `image=`*(context: Context, image: Image) = + pixie_context_set_image(context, image) + +proc pixie_context_get_fill_style(context: Context): Paint {.importc: "pixie_context_get_fill_style", cdecl.} + +proc fillStyle*(context: Context): Paint {.inline.} = + pixie_context_get_fill_style(context) + +proc pixie_context_set_fill_style(context: Context, fillStyle: Paint) {.importc: "pixie_context_set_fill_style", cdecl.} + +proc `fillStyle=`*(context: Context, fillStyle: Paint) = + pixie_context_set_fill_style(context, fillStyle) + +proc pixie_context_get_stroke_style(context: Context): Paint {.importc: "pixie_context_get_stroke_style", cdecl.} + +proc strokeStyle*(context: Context): Paint {.inline.} = + pixie_context_get_stroke_style(context) + +proc pixie_context_set_stroke_style(context: Context, strokeStyle: Paint) {.importc: "pixie_context_set_stroke_style", cdecl.} + +proc `strokeStyle=`*(context: Context, strokeStyle: Paint) = + pixie_context_set_stroke_style(context, strokeStyle) + +proc pixie_context_get_global_alpha(context: Context): float32 {.importc: "pixie_context_get_global_alpha", cdecl.} + +proc globalAlpha*(context: Context): float32 {.inline.} = + pixie_context_get_global_alpha(context) + +proc pixie_context_set_global_alpha(context: Context, globalAlpha: float32) {.importc: "pixie_context_set_global_alpha", cdecl.} + +proc `globalAlpha=`*(context: Context, globalAlpha: float32) = + pixie_context_set_global_alpha(context, globalAlpha) + +proc pixie_context_get_line_width(context: Context): float32 {.importc: "pixie_context_get_line_width", cdecl.} + +proc lineWidth*(context: Context): float32 {.inline.} = + pixie_context_get_line_width(context) + +proc pixie_context_set_line_width(context: Context, lineWidth: float32) {.importc: "pixie_context_set_line_width", cdecl.} + +proc `lineWidth=`*(context: Context, lineWidth: float32) = + pixie_context_set_line_width(context, lineWidth) + +proc pixie_context_get_miter_limit(context: Context): float32 {.importc: "pixie_context_get_miter_limit", cdecl.} + +proc miterLimit*(context: Context): float32 {.inline.} = + pixie_context_get_miter_limit(context) + +proc pixie_context_set_miter_limit(context: Context, miterLimit: float32) {.importc: "pixie_context_set_miter_limit", cdecl.} + +proc `miterLimit=`*(context: Context, miterLimit: float32) = + pixie_context_set_miter_limit(context, miterLimit) + +proc pixie_context_get_line_cap(context: Context): LineCap {.importc: "pixie_context_get_line_cap", cdecl.} + +proc lineCap*(context: Context): LineCap {.inline.} = + pixie_context_get_line_cap(context) + +proc pixie_context_set_line_cap(context: Context, lineCap: LineCap) {.importc: "pixie_context_set_line_cap", cdecl.} + +proc `lineCap=`*(context: Context, lineCap: LineCap) = + pixie_context_set_line_cap(context, lineCap) + +proc pixie_context_get_line_join(context: Context): LineJoin {.importc: "pixie_context_get_line_join", cdecl.} + +proc lineJoin*(context: Context): LineJoin {.inline.} = + pixie_context_get_line_join(context) + +proc pixie_context_set_line_join(context: Context, lineJoin: LineJoin) {.importc: "pixie_context_set_line_join", cdecl.} + +proc `lineJoin=`*(context: Context, lineJoin: LineJoin) = + pixie_context_set_line_join(context, lineJoin) + +proc pixie_context_get_font(context: Context): cstring {.importc: "pixie_context_get_font", cdecl.} + +proc font*(context: Context): cstring {.inline.} = + pixie_context_get_font(context).`$` + +proc pixie_context_set_font(context: Context, font: cstring) {.importc: "pixie_context_set_font", cdecl.} + +proc `font=`*(context: Context, font: string) = + pixie_context_set_font(context, font.cstring) + +proc pixie_context_get_font_size(context: Context): float32 {.importc: "pixie_context_get_font_size", cdecl.} + +proc fontSize*(context: Context): float32 {.inline.} = + pixie_context_get_font_size(context) + +proc pixie_context_set_font_size(context: Context, fontSize: float32) {.importc: "pixie_context_set_font_size", cdecl.} + +proc `fontSize=`*(context: Context, fontSize: float32) = + pixie_context_set_font_size(context, fontSize) + +proc pixie_context_get_text_align(context: Context): HorizontalAlignment {.importc: "pixie_context_get_text_align", cdecl.} + +proc textAlign*(context: Context): HorizontalAlignment {.inline.} = + pixie_context_get_text_align(context) + +proc pixie_context_set_text_align(context: Context, textAlign: HorizontalAlignment) {.importc: "pixie_context_set_text_align", cdecl.} + +proc `textAlign=`*(context: Context, textAlign: HorizontalAlignment) = + pixie_context_set_text_align(context, textAlign) + +proc pixie_check_error(): bool {.importc: "pixie_check_error", cdecl.} + +proc checkError*(): bool {.inline.} = + result = pixie_check_error() + +proc pixie_take_error(): cstring {.importc: "pixie_take_error", cdecl.} + +proc takeError*(): cstring {.inline.} = + result = pixie_take_error() + +proc pixie_seq_float32_len(s: SeqFloat32): int {.importc: "pixie_seq_float32_len", cdecl.} + +proc pixie_seq_float32_add(s: SeqFloat32, v: float32) {.importc: "pixie_seq_float32_add", cdecl.} + +proc pixie_seq_float32_get(s: SeqFloat32, i: int): float32 {.importc: "pixie_seq_float32_get", cdecl.} + +proc pixie_seq_float32_set(s: SeqFloat32, i: int, v: float32) {.importc: "pixie_seq_float32_set", cdecl.} + +proc pixie_seq_float32_remove(s: SeqFloat32, i: int) {.importc: "pixie_seq_float32_remove", cdecl.} + +proc pixie_seq_float32_clear(s: SeqFloat32) {.importc: "pixie_seq_float32_clear", cdecl.} + +proc pixie_new_seq_float32*(): SeqFloat32 {.importc: "pixie_new_seq_float32", cdecl.} + +proc newSeqFloat32*(): SeqFloat32 = + pixie_new_seq_float32() + +proc pixie_seq_span_len(s: SeqSpan): int {.importc: "pixie_seq_span_len", cdecl.} + +proc pixie_seq_span_add(s: SeqSpan, v: Span) {.importc: "pixie_seq_span_add", cdecl.} + +proc pixie_seq_span_get(s: SeqSpan, i: int): Span {.importc: "pixie_seq_span_get", cdecl.} + +proc pixie_seq_span_set(s: SeqSpan, i: int, v: Span) {.importc: "pixie_seq_span_set", cdecl.} + +proc pixie_seq_span_remove(s: SeqSpan, i: int) {.importc: "pixie_seq_span_remove", cdecl.} + +proc pixie_seq_span_clear(s: SeqSpan) {.importc: "pixie_seq_span_clear", cdecl.} + +proc pixie_new_seq_span*(): SeqSpan {.importc: "pixie_new_seq_span", cdecl.} + +proc newSeqSpan*(): SeqSpan = + pixie_new_seq_span() + +proc pixie_seq_span_typeset(spans: SeqSpan, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, wrap: bool): Arrangement {.importc: "pixie_seq_span_typeset", cdecl.} + +proc typeset*(spans: SeqSpan, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment, wrap: bool): Arrangement {.inline.} = + result = pixie_seq_span_typeset(spans, bounds, hAlign, vAlign, wrap) + +proc pixie_seq_span_compute_bounds(spans: SeqSpan): Vec2 {.importc: "pixie_seq_span_compute_bounds", cdecl.} + +proc computeBounds*(spans: SeqSpan): Vec2 {.inline.} = + result = pixie_seq_span_compute_bounds(spans) + +proc pixie_image_write_file(image: Image, file_path: cstring) {.importc: "pixie_image_write_file", cdecl.} + +proc writeFile*(image: Image, filePath: string) {.inline.} = + pixie_image_write_file(image, filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_wh(image: Image): Vec2 {.importc: "pixie_image_wh", cdecl.} + +proc wh*(image: Image): Vec2 {.inline.} = + result = pixie_image_wh(image) + +proc pixie_image_copy(image: Image): Image {.importc: "pixie_image_copy", cdecl.} + +proc copy*(image: Image): Image {.inline.} = + result = pixie_image_copy(image) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_get_color(image: Image, x: int, y: int): Color {.importc: "pixie_image_get_color", cdecl.} + +proc getColor*(image: Image, x: int, y: int): Color {.inline.} = + result = pixie_image_get_color(image, x, y) + +proc pixie_image_set_color(image: Image, x: int, y: int, color: Color) {.importc: "pixie_image_set_color", cdecl.} + +proc setColor*(image: Image, x: int, y: int, color: Color) {.inline.} = + pixie_image_set_color(image, x, y, color) + +proc pixie_image_fill(image: Image, color: Color) {.importc: "pixie_image_fill", cdecl.} + +proc fill*(image: Image, color: Color) {.inline.} = + pixie_image_fill(image, color) + +proc pixie_image_flip_horizontal(image: Image) {.importc: "pixie_image_flip_horizontal", cdecl.} + +proc flipHorizontal*(image: Image) {.inline.} = + pixie_image_flip_horizontal(image) + +proc pixie_image_flip_vertical(image: Image) {.importc: "pixie_image_flip_vertical", cdecl.} + +proc flipVertical*(image: Image) {.inline.} = + pixie_image_flip_vertical(image) + +proc pixie_image_sub_image(image: Image, x: int, y: int, w: int, h: int): Image {.importc: "pixie_image_sub_image", cdecl.} + +proc subImage*(image: Image, x: int, y: int, w: int, h: int): Image {.inline.} = + result = pixie_image_sub_image(image, x, y, w, h) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_minify_by2(image: Image, power: int): Image {.importc: "pixie_image_minify_by2", cdecl.} + +proc minifyBy2*(image: Image, power: int): Image {.inline.} = + result = pixie_image_minify_by2(image, power) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_magnify_by2(image: Image, power: int): Image {.importc: "pixie_image_magnify_by2", cdecl.} + +proc magnifyBy2*(image: Image, power: int): Image {.inline.} = + result = pixie_image_magnify_by2(image, power) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_apply_opacity(target: Image, opacity: float32) {.importc: "pixie_image_apply_opacity", cdecl.} + +proc applyOpacity*(target: Image, opacity: float32) {.inline.} = + pixie_image_apply_opacity(target, opacity) + +proc pixie_image_invert(target: Image) {.importc: "pixie_image_invert", cdecl.} + +proc invert*(target: Image) {.inline.} = + pixie_image_invert(target) + +proc pixie_image_blur(image: Image, radius: float32, out_of_bounds: Color) {.importc: "pixie_image_blur", cdecl.} + +proc blur*(image: Image, radius: float32, outOfBounds: Color) {.inline.} = + pixie_image_blur(image, radius, outOfBounds) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_new_mask(image: Image): Mask {.importc: "pixie_image_new_mask", cdecl.} + +proc newMask*(image: Image): Mask {.inline.} = + result = pixie_image_new_mask(image) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_resize(src_image: Image, width: int, height: int): Image {.importc: "pixie_image_resize", cdecl.} + +proc resize*(srcImage: Image, width: int, height: int): Image {.inline.} = + result = pixie_image_resize(srcImage, width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_shadow(image: Image, offset: Vec2, spread: float32, blur: float32, color: Color): Image {.importc: "pixie_image_shadow", cdecl.} + +proc shadow*(image: Image, offset: Vec2, spread: float32, blur: float32, color: Color): Image {.inline.} = + result = pixie_image_shadow(image, offset, spread, blur, color) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_super_image(image: Image, x: int, y: int, w: int, h: int): Image {.importc: "pixie_image_super_image", cdecl.} + +proc superImage*(image: Image, x: int, y: int, w: int, h: int): Image {.inline.} = + result = pixie_image_super_image(image, x, y, w, h) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_mask_draw(image: Image, mask: Mask, transform: Mat3, blend_mode: BlendMode) {.importc: "pixie_image_mask_draw", cdecl.} + +proc draw*(image: Image, mask: Mask, transform: Mat3, blendMode: BlendMode) {.inline.} = + pixie_image_mask_draw(image, mask, transform, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_image_draw(a: Image, b: Image, transform: Mat3, blend_mode: BlendMode) {.importc: "pixie_image_image_draw", cdecl.} + +proc draw*(a: Image, b: Image, transform: Mat3, blendMode: BlendMode) {.inline.} = + pixie_image_image_draw(a, b, transform, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_fill_gradient(image: Image, paint: Paint) {.importc: "pixie_image_fill_gradient", cdecl.} + +proc fillGradient*(image: Image, paint: Paint) {.inline.} = + pixie_image_fill_gradient(image, paint) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_arrangement_fill_text(target: Image, arrangement: Arrangement, transform: Mat3) {.importc: "pixie_image_arrangement_fill_text", cdecl.} + +proc fillText*(target: Image, arrangement: Arrangement, transform: Mat3) {.inline.} = + pixie_image_arrangement_fill_text(target, arrangement, transform) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_font_fill_text(target: Image, font: Font, text: cstring, transform: Mat3, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment) {.importc: "pixie_image_font_fill_text", cdecl.} + +proc fillText*(target: Image, font: Font, text: string, transform: Mat3, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment) {.inline.} = + pixie_image_font_fill_text(target, font, text.cstring, transform, bounds, hAlign, vAlign) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_image_arrangement_stroke_text", cdecl.} + +proc strokeText*(target: Image, arrangement: Arrangement, transform: Mat3, strokeWidth: float32, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32) {.inline.} = + pixie_image_arrangement_stroke_text(target, arrangement, transform, strokeWidth, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_image_font_stroke_text", cdecl.} + +proc strokeText*(target: Image, font: Font, text: string, transform: Mat3, strokeWidth: float32, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32) {.inline.} = + pixie_image_font_stroke_text(target, font, text.cstring, transform, strokeWidth, bounds, hAlign, vAlign, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_fill_path(image: Image, path: Path, paint: Paint, transform: Mat3, winding_rule: WindingRule) {.importc: "pixie_image_fill_path", cdecl.} + +proc fillPath*(image: Image, path: Path, paint: Paint, transform: Mat3, windingRule: WindingRule) {.inline.} = + pixie_image_fill_path(image, path, paint, transform, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_image_stroke_path", cdecl.} + +proc strokePath*(image: Image, path: Path, paint: Paint, transform: Mat3, strokeWidth: float32, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32) {.inline.} = + pixie_image_stroke_path(image, path, paint, transform, strokeWidth, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_image_new_context(image: Image): Context {.importc: "pixie_image_new_context", cdecl.} + +proc newContext*(image: Image): Context {.inline.} = + result = pixie_image_new_context(image) + +proc pixie_mask_write_file(mask: Mask, file_path: cstring) {.importc: "pixie_mask_write_file", cdecl.} + +proc writeFile*(mask: Mask, filePath: string) {.inline.} = + pixie_mask_write_file(mask, filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_wh(mask: Mask): Vec2 {.importc: "pixie_mask_wh", cdecl.} + +proc wh*(mask: Mask): Vec2 {.inline.} = + result = pixie_mask_wh(mask) + +proc pixie_mask_copy(mask: Mask): Mask {.importc: "pixie_mask_copy", cdecl.} + +proc copy*(mask: Mask): Mask {.inline.} = + result = pixie_mask_copy(mask) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_get_value(mask: Mask, x: int, y: int): uint8 {.importc: "pixie_mask_get_value", cdecl.} + +proc getValue*(mask: Mask, x: int, y: int): uint8 {.inline.} = + result = pixie_mask_get_value(mask, x, y) + +proc pixie_mask_set_value(mask: Mask, x: int, y: int, value: uint8) {.importc: "pixie_mask_set_value", cdecl.} + +proc setValue*(mask: Mask, x: int, y: int, value: uint8) {.inline.} = + pixie_mask_set_value(mask, x, y, value) + +proc pixie_mask_fill(mask: Mask, value: uint8) {.importc: "pixie_mask_fill", cdecl.} + +proc fill*(mask: Mask, value: uint8) {.inline.} = + pixie_mask_fill(mask, value) + +proc pixie_mask_minify_by2(mask: Mask, power: int): Mask {.importc: "pixie_mask_minify_by2", cdecl.} + +proc minifyBy2*(mask: Mask, power: int): Mask {.inline.} = + result = pixie_mask_minify_by2(mask, power) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_spread(mask: Mask, spread: float32) {.importc: "pixie_mask_spread", cdecl.} + +proc spread*(mask: Mask, spread: float32) {.inline.} = + pixie_mask_spread(mask, spread) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_ceil(mask: Mask) {.importc: "pixie_mask_ceil", cdecl.} + +proc ceil*(mask: Mask) {.inline.} = + pixie_mask_ceil(mask) + +proc pixie_mask_new_image(mask: Mask): Image {.importc: "pixie_mask_new_image", cdecl.} + +proc newImage*(mask: Mask): Image {.inline.} = + result = pixie_mask_new_image(mask) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_apply_opacity(target: Mask, opacity: float32) {.importc: "pixie_mask_apply_opacity", cdecl.} + +proc applyOpacity*(target: Mask, opacity: float32) {.inline.} = + pixie_mask_apply_opacity(target, opacity) + +proc pixie_mask_invert(target: Mask) {.importc: "pixie_mask_invert", cdecl.} + +proc invert*(target: Mask) {.inline.} = + pixie_mask_invert(target) + +proc pixie_mask_blur(mask: Mask, radius: float32, out_of_bounds: uint8) {.importc: "pixie_mask_blur", cdecl.} + +proc blur*(mask: Mask, radius: float32, outOfBounds: uint8) {.inline.} = + pixie_mask_blur(mask, radius, outOfBounds) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_mask_draw(a: Mask, b: Mask, transform: Mat3, blend_mode: BlendMode) {.importc: "pixie_mask_mask_draw", cdecl.} + +proc draw*(a: Mask, b: Mask, transform: Mat3, blendMode: BlendMode) {.inline.} = + pixie_mask_mask_draw(a, b, transform, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_image_draw(mask: Mask, image: Image, transform: Mat3, blend_mode: BlendMode) {.importc: "pixie_mask_image_draw", cdecl.} + +proc draw*(mask: Mask, image: Image, transform: Mat3, blendMode: BlendMode) {.inline.} = + pixie_mask_image_draw(mask, image, transform, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_arrangement_fill_text(target: Mask, arrangement: Arrangement, transform: Mat3) {.importc: "pixie_mask_arrangement_fill_text", cdecl.} + +proc fillText*(target: Mask, arrangement: Arrangement, transform: Mat3) {.inline.} = + pixie_mask_arrangement_fill_text(target, arrangement, transform) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_font_fill_text(target: Mask, font: Font, text: cstring, transform: Mat3, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment) {.importc: "pixie_mask_font_fill_text", cdecl.} + +proc fillText*(target: Mask, font: Font, text: string, transform: Mat3, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment) {.inline.} = + pixie_mask_font_fill_text(target, font, text.cstring, transform, bounds, hAlign, vAlign) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_mask_arrangement_stroke_text", cdecl.} + +proc strokeText*(target: Mask, arrangement: Arrangement, transform: Mat3, strokeWidth: float32, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32) {.inline.} = + pixie_mask_arrangement_stroke_text(target, arrangement, transform, strokeWidth, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_mask_font_stroke_text", cdecl.} + +proc strokeText*(target: Mask, font: Font, text: string, transform: Mat3, strokeWidth: float32, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32) {.inline.} = + pixie_mask_font_stroke_text(target, font, text.cstring, transform, strokeWidth, bounds, hAlign, vAlign, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_mask_fill_path(mask: Mask, path: Path, transform: Mat3, winding_rule: WindingRule, blend_mode: BlendMode) {.importc: "pixie_mask_fill_path", cdecl.} + +proc fillPath*(mask: Mask, path: Path, transform: Mat3, windingRule: WindingRule, blendMode: BlendMode) {.inline.} = + pixie_mask_fill_path(mask, path, transform, windingRule, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_mask_stroke_path", cdecl.} + +proc strokePath*(mask: Mask, path: Path, transform: Mat3, strokeWidth: float32, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32, blendMode: BlendMode) {.inline.} = + pixie_mask_stroke_path(mask, path, transform, strokeWidth, lineCap, lineJoin, miterLimit, dashes, blendMode) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_paint_gradient_handle_positions_len(s: Paint): int {.importc: "pixie_paint_gradient_handle_positions_len", cdecl.} + +proc pixie_paint_gradient_handle_positions_add(s: Paint, v: Vec2) {.importc: "pixie_paint_gradient_handle_positions_add", cdecl.} + +proc pixie_paint_gradient_handle_positions_get(s: Paint, i: int): Vec2 {.importc: "pixie_paint_gradient_handle_positions_get", cdecl.} + +proc pixie_paint_gradient_handle_positions_set(s: Paint, i: int, v: Vec2) {.importc: "pixie_paint_gradient_handle_positions_set", cdecl.} + +proc pixie_paint_gradient_handle_positions_remove(s: Paint, i: int) {.importc: "pixie_paint_gradient_handle_positions_remove", cdecl.} + +proc pixie_paint_gradient_handle_positions_clear(s: Paint) {.importc: "pixie_paint_gradient_handle_positions_clear", cdecl.} + +proc pixie_paint_gradient_stops_len(s: Paint): int {.importc: "pixie_paint_gradient_stops_len", cdecl.} + +proc pixie_paint_gradient_stops_add(s: Paint, v: ColorStop) {.importc: "pixie_paint_gradient_stops_add", cdecl.} + +proc pixie_paint_gradient_stops_get(s: Paint, i: int): ColorStop {.importc: "pixie_paint_gradient_stops_get", cdecl.} + +proc pixie_paint_gradient_stops_set(s: Paint, i: int, v: ColorStop) {.importc: "pixie_paint_gradient_stops_set", cdecl.} + +proc pixie_paint_gradient_stops_remove(s: Paint, i: int) {.importc: "pixie_paint_gradient_stops_remove", cdecl.} + +proc pixie_paint_gradient_stops_clear(s: Paint) {.importc: "pixie_paint_gradient_stops_clear", cdecl.} + +proc pixie_paint_new_paint(paint: Paint): Paint {.importc: "pixie_paint_new_paint", cdecl.} + +proc newPaint*(paint: Paint): Paint {.inline.} = + result = pixie_paint_new_paint(paint) + +proc pixie_path_transform(path: Path, mat: Mat3) {.importc: "pixie_path_transform", cdecl.} + +proc transform*(path: Path, mat: Mat3) {.inline.} = + pixie_path_transform(path, mat) + +proc pixie_path_add_path(path: Path, other: Path) {.importc: "pixie_path_add_path", cdecl.} + +proc addPath*(path: Path, other: Path) {.inline.} = + pixie_path_add_path(path, other) + +proc pixie_path_close_path(path: Path) {.importc: "pixie_path_close_path", cdecl.} + +proc closePath*(path: Path) {.inline.} = + pixie_path_close_path(path) + +proc pixie_path_compute_bounds(path: Path, transform: Mat3): Rect {.importc: "pixie_path_compute_bounds", cdecl.} + +proc computeBounds*(path: Path, transform: Mat3): Rect {.inline.} = + result = pixie_path_compute_bounds(path, transform) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_path_fill_overlaps(path: Path, test: Vec2, transform: Mat3, winding_rule: WindingRule): bool {.importc: "pixie_path_fill_overlaps", cdecl.} + +proc fillOverlaps*(path: Path, test: Vec2, transform: Mat3, windingRule: WindingRule): bool {.inline.} = + result = pixie_path_fill_overlaps(path, test, transform, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +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 {.importc: "pixie_path_stroke_overlaps", cdecl.} + +proc strokeOverlaps*(path: Path, test: Vec2, transform: Mat3, strokeWidth: float32, lineCap: LineCap, lineJoin: LineJoin, miterLimit: float32, dashes: SeqFloat32): bool {.inline.} = + result = pixie_path_stroke_overlaps(path, test, transform, strokeWidth, lineCap, lineJoin, miterLimit, dashes) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_path_move_to(path: Path, x: float32, y: float32) {.importc: "pixie_path_move_to", cdecl.} + +proc moveTo*(path: Path, x: float32, y: float32) {.inline.} = + pixie_path_move_to(path, x, y) + +proc pixie_path_line_to(path: Path, x: float32, y: float32) {.importc: "pixie_path_line_to", cdecl.} + +proc lineTo*(path: Path, x: float32, y: float32) {.inline.} = + pixie_path_line_to(path, x, y) + +proc pixie_path_bezier_curve_to(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, x3: float32, y3: float32) {.importc: "pixie_path_bezier_curve_to", cdecl.} + +proc bezierCurveTo*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, x3: float32, y3: float32) {.inline.} = + pixie_path_bezier_curve_to(path, x1, y1, x2, y2, x3, y3) + +proc pixie_path_quadratic_curve_to(path: Path, x1: float32, y1: float32, x2: float32, y2: float32) {.importc: "pixie_path_quadratic_curve_to", cdecl.} + +proc quadraticCurveTo*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32) {.inline.} = + pixie_path_quadratic_curve_to(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) {.importc: "pixie_path_elliptical_arc_to", cdecl.} + +proc ellipticalArcTo*(path: Path, rx: float32, ry: float32, xAxisRotation: float32, largeArcFlag: bool, sweepFlag: bool, x: float32, y: float32) {.inline.} = + pixie_path_elliptical_arc_to(path, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x, y) + +proc pixie_path_arc(path: Path, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.importc: "pixie_path_arc", cdecl.} + +proc arc*(path: Path, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.inline.} = + pixie_path_arc(path, x, y, r, a0, a1, ccw) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_path_arc_to(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, r: float32) {.importc: "pixie_path_arc_to", cdecl.} + +proc arcTo*(path: Path, x1: float32, y1: float32, x2: float32, y2: float32, r: float32) {.inline.} = + pixie_path_arc_to(path, x1, y1, x2, y2, r) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_path_rect(path: Path, x: float32, y: float32, w: float32, h: float32, clockwise: bool) {.importc: "pixie_path_rect", cdecl.} + +proc rect*(path: Path, x: float32, y: float32, w: float32, h: float32, clockwise: bool) {.inline.} = + pixie_path_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) {.importc: "pixie_path_rounded_rect", cdecl.} + +proc roundedRect*(path: Path, x: float32, y: float32, w: float32, h: float32, nw: float32, ne: float32, se: float32, sw: float32, clockwise: bool) {.inline.} = + pixie_path_rounded_rect(path, x, y, w, h, nw, ne, se, sw, clockwise) + +proc pixie_path_ellipse(path: Path, cx: float32, cy: float32, rx: float32, ry: float32) {.importc: "pixie_path_ellipse", cdecl.} + +proc ellipse*(path: Path, cx: float32, cy: float32, rx: float32, ry: float32) {.inline.} = + pixie_path_ellipse(path, cx, cy, rx, ry) + +proc pixie_path_circle(path: Path, cx: float32, cy: float32, r: float32) {.importc: "pixie_path_circle", cdecl.} + +proc circle*(path: Path, cx: float32, cy: float32, r: float32) {.inline.} = + pixie_path_circle(path, cx, cy, r) + +proc pixie_path_polygon(path: Path, x: float32, y: float32, size: float32, sides: int) {.importc: "pixie_path_polygon", cdecl.} + +proc polygon*(path: Path, x: float32, y: float32, size: float32, sides: int) {.inline.} = + pixie_path_polygon(path, x, y, size, sides) + +proc pixie_typeface_ascent(typeface: Typeface): float32 {.importc: "pixie_typeface_ascent", cdecl.} + +proc ascent*(typeface: Typeface): float32 {.inline.} = + result = pixie_typeface_ascent(typeface) + +proc pixie_typeface_descent(typeface: Typeface): float32 {.importc: "pixie_typeface_descent", cdecl.} + +proc descent*(typeface: Typeface): float32 {.inline.} = + result = pixie_typeface_descent(typeface) + +proc pixie_typeface_line_gap(typeface: Typeface): float32 {.importc: "pixie_typeface_line_gap", cdecl.} + +proc lineGap*(typeface: Typeface): float32 {.inline.} = + result = pixie_typeface_line_gap(typeface) + +proc pixie_typeface_line_height(typeface: Typeface): float32 {.importc: "pixie_typeface_line_height", cdecl.} + +proc lineHeight*(typeface: Typeface): float32 {.inline.} = + result = pixie_typeface_line_height(typeface) + +proc pixie_typeface_get_glyph_path(typeface: Typeface, rune: int32): Path {.importc: "pixie_typeface_get_glyph_path", cdecl.} + +proc getGlyphPath*(typeface: Typeface, rune: Rune): Path {.inline.} = + result = pixie_typeface_get_glyph_path(typeface, rune.int32) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_typeface_get_advance(typeface: Typeface, rune: int32): float32 {.importc: "pixie_typeface_get_advance", cdecl.} + +proc getAdvance*(typeface: Typeface, rune: Rune): float32 {.inline.} = + result = pixie_typeface_get_advance(typeface, rune.int32) + +proc pixie_typeface_get_kerning_adjustment(typeface: Typeface, left: int32, right: int32): float32 {.importc: "pixie_typeface_get_kerning_adjustment", cdecl.} + +proc getKerningAdjustment*(typeface: Typeface, left: Rune, right: Rune): float32 {.inline.} = + result = pixie_typeface_get_kerning_adjustment(typeface, left.int32, right.int32) + +proc pixie_typeface_new_font(typeface: Typeface): Font {.importc: "pixie_typeface_new_font", cdecl.} + +proc newFont*(typeface: Typeface): Font {.inline.} = + result = pixie_typeface_new_font(typeface) + +proc pixie_font_paints_len(s: Font): int {.importc: "pixie_font_paints_len", cdecl.} + +proc pixie_font_paints_add(s: Font, v: Paint) {.importc: "pixie_font_paints_add", cdecl.} + +proc pixie_font_paints_get(s: Font, i: int): Paint {.importc: "pixie_font_paints_get", cdecl.} + +proc pixie_font_paints_set(s: Font, i: int, v: Paint) {.importc: "pixie_font_paints_set", cdecl.} + +proc pixie_font_paints_remove(s: Font, i: int) {.importc: "pixie_font_paints_remove", cdecl.} + +proc pixie_font_paints_clear(s: Font) {.importc: "pixie_font_paints_clear", cdecl.} + +proc pixie_font_scale(font: Font): float32 {.importc: "pixie_font_scale", cdecl.} + +proc scale*(font: Font): float32 {.inline.} = + result = pixie_font_scale(font) + +proc pixie_font_default_line_height(font: Font): float32 {.importc: "pixie_font_default_line_height", cdecl.} + +proc defaultLineHeight*(font: Font): float32 {.inline.} = + result = pixie_font_default_line_height(font) + +proc pixie_font_typeset(font: Font, text: cstring, bounds: Vec2, h_align: HorizontalAlignment, v_align: VerticalAlignment, wrap: bool): Arrangement {.importc: "pixie_font_typeset", cdecl.} + +proc typeset*(font: Font, text: string, bounds: Vec2, hAlign: HorizontalAlignment, vAlign: VerticalAlignment, wrap: bool): Arrangement {.inline.} = + result = pixie_font_typeset(font, text.cstring, bounds, hAlign, vAlign, wrap) + +proc pixie_font_compute_bounds(font: Font, text: cstring): Vec2 {.importc: "pixie_font_compute_bounds", cdecl.} + +proc computeBounds*(font: Font, text: string): Vec2 {.inline.} = + result = pixie_font_compute_bounds(font, text.cstring) + +proc pixie_arrangement_compute_bounds(arrangement: Arrangement): Vec2 {.importc: "pixie_arrangement_compute_bounds", cdecl.} + +proc computeBounds*(arrangement: Arrangement): Vec2 {.inline.} = + result = pixie_arrangement_compute_bounds(arrangement) + +proc pixie_context_line_dash_len(s: Context): int {.importc: "pixie_context_line_dash_len", cdecl.} + +proc pixie_context_line_dash_add(s: Context, v: float32) {.importc: "pixie_context_line_dash_add", cdecl.} + +proc pixie_context_line_dash_get(s: Context, i: int): float32 {.importc: "pixie_context_line_dash_get", cdecl.} + +proc pixie_context_line_dash_set(s: Context, i: int, v: float32) {.importc: "pixie_context_line_dash_set", cdecl.} + +proc pixie_context_line_dash_remove(s: Context, i: int) {.importc: "pixie_context_line_dash_remove", cdecl.} + +proc pixie_context_line_dash_clear(s: Context) {.importc: "pixie_context_line_dash_clear", cdecl.} + +proc pixie_context_save(ctx: Context) {.importc: "pixie_context_save", cdecl.} + +proc save*(ctx: Context) {.inline.} = + pixie_context_save(ctx) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_save_layer(ctx: Context) {.importc: "pixie_context_save_layer", cdecl.} + +proc saveLayer*(ctx: Context) {.inline.} = + pixie_context_save_layer(ctx) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_restore(ctx: Context) {.importc: "pixie_context_restore", cdecl.} + +proc restore*(ctx: Context) {.inline.} = + pixie_context_restore(ctx) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_begin_path(ctx: Context) {.importc: "pixie_context_begin_path", cdecl.} + +proc beginPath*(ctx: Context) {.inline.} = + pixie_context_begin_path(ctx) + +proc pixie_context_close_path(ctx: Context) {.importc: "pixie_context_close_path", cdecl.} + +proc closePath*(ctx: Context) {.inline.} = + pixie_context_close_path(ctx) + +proc pixie_context_path_fill(ctx: Context, path: Path, winding_rule: WindingRule) {.importc: "pixie_context_path_fill", cdecl.} + +proc fill*(ctx: Context, path: Path, windingRule: WindingRule) {.inline.} = + pixie_context_path_fill(ctx, path, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_winding_rule_fill(ctx: Context, winding_rule: WindingRule) {.importc: "pixie_context_winding_rule_fill", cdecl.} + +proc fill*(ctx: Context, windingRule: WindingRule) {.inline.} = + pixie_context_winding_rule_fill(ctx, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_path_clip(ctx: Context, path: Path, winding_rule: WindingRule) {.importc: "pixie_context_path_clip", cdecl.} + +proc clip*(ctx: Context, path: Path, windingRule: WindingRule) {.inline.} = + pixie_context_path_clip(ctx, path, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_winding_rule_clip(ctx: Context, winding_rule: WindingRule) {.importc: "pixie_context_winding_rule_clip", cdecl.} + +proc clip*(ctx: Context, windingRule: WindingRule) {.inline.} = + pixie_context_winding_rule_clip(ctx, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_path_stroke(ctx: Context, path: Path) {.importc: "pixie_context_path_stroke", cdecl.} + +proc stroke*(ctx: Context, path: Path) {.inline.} = + pixie_context_path_stroke(ctx, path) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_stroke(ctx: Context) {.importc: "pixie_context_stroke", cdecl.} + +proc stroke*(ctx: Context) {.inline.} = + pixie_context_stroke(ctx) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_measure_text(ctx: Context, text: cstring): TextMetrics {.importc: "pixie_context_measure_text", cdecl.} + +proc measureText*(ctx: Context, text: string): TextMetrics {.inline.} = + result = pixie_context_measure_text(ctx, text.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_get_transform(ctx: Context): Mat3 {.importc: "pixie_context_get_transform", cdecl.} + +proc getTransform*(ctx: Context): Mat3 {.inline.} = + result = pixie_context_get_transform(ctx) + +proc pixie_context_set_transform(ctx: Context, transform: Mat3) {.importc: "pixie_context_set_transform", cdecl.} + +proc setTransform*(ctx: Context, transform: Mat3) {.inline.} = + pixie_context_set_transform(ctx, transform) + +proc pixie_context_transform(ctx: Context, transform: Mat3) {.importc: "pixie_context_transform", cdecl.} + +proc transform*(ctx: Context, transform: Mat3) {.inline.} = + pixie_context_transform(ctx, transform) + +proc pixie_context_reset_transform(ctx: Context) {.importc: "pixie_context_reset_transform", cdecl.} + +proc resetTransform*(ctx: Context) {.inline.} = + pixie_context_reset_transform(ctx) + +proc pixie_context_draw_image1(ctx: Context, image: Image, dx: float32, dy: float32) {.importc: "pixie_context_draw_image1", cdecl.} + +proc drawImage1*(ctx: Context, image: Image, dx: float32, dy: float32) {.inline.} = + pixie_context_draw_image1(ctx, image, dx, dy) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_draw_image2(ctx: Context, image: Image, dx: float32, dy: float32, d_width: float32, d_height: float32) {.importc: "pixie_context_draw_image2", cdecl.} + +proc drawImage2*(ctx: Context, image: Image, dx: float32, dy: float32, dWidth: float32, dHeight: float32) {.inline.} = + pixie_context_draw_image2(ctx, image, dx, dy, dWidth, dHeight) + if checkError(): + raise newException(PixieError, $takeError()) + +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) {.importc: "pixie_context_draw_image3", cdecl.} + +proc drawImage3*(ctx: Context, image: Image, sx: float32, sy: float32, sWidth: float32, sHeight: float32, dx: float32, dy: float32, dWidth: float32, dHeight: float32) {.inline.} = + pixie_context_draw_image3(ctx, image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_move_to(ctx: Context, x: float32, y: float32) {.importc: "pixie_context_move_to", cdecl.} + +proc moveTo*(ctx: Context, x: float32, y: float32) {.inline.} = + pixie_context_move_to(ctx, x, y) + +proc pixie_context_line_to(ctx: Context, x: float32, y: float32) {.importc: "pixie_context_line_to", cdecl.} + +proc lineTo*(ctx: Context, x: float32, y: float32) {.inline.} = + pixie_context_line_to(ctx, x, y) + +proc pixie_context_bezier_curve_to(ctx: Context, cp1x: float32, cp1y: float32, cp2x: float32, cp2y: float32, x: float32, y: float32) {.importc: "pixie_context_bezier_curve_to", cdecl.} + +proc bezierCurveTo*(ctx: Context, cp1x: float32, cp1y: float32, cp2x: float32, cp2y: float32, x: float32, y: float32) {.inline.} = + pixie_context_bezier_curve_to(ctx, cp1x, cp1y, cp2x, cp2y, x, y) + +proc pixie_context_quadratic_curve_to(ctx: Context, cpx: float32, cpy: float32, x: float32, y: float32) {.importc: "pixie_context_quadratic_curve_to", cdecl.} + +proc quadraticCurveTo*(ctx: Context, cpx: float32, cpy: float32, x: float32, y: float32) {.inline.} = + pixie_context_quadratic_curve_to(ctx, cpx, cpy, x, y) + +proc pixie_context_arc(ctx: Context, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.importc: "pixie_context_arc", cdecl.} + +proc arc*(ctx: Context, x: float32, y: float32, r: float32, a0: float32, a1: float32, ccw: bool) {.inline.} = + pixie_context_arc(ctx, x, y, r, a0, a1, ccw) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_arc_to(ctx: Context, x1: float32, y1: float32, x2: float32, y2: float32, radius: float32) {.importc: "pixie_context_arc_to", cdecl.} + +proc arcTo*(ctx: Context, x1: float32, y1: float32, x2: float32, y2: float32, radius: float32) {.inline.} = + pixie_context_arc_to(ctx, x1, y1, x2, y2, radius) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_rect(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.importc: "pixie_context_rect", cdecl.} + +proc rect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.inline.} = + pixie_context_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) {.importc: "pixie_context_rounded_rect", cdecl.} + +proc roundedRect*(ctx: Context, x: float32, y: float32, w: float32, h: float32, nw: float32, ne: float32, se: float32, sw: float32) {.inline.} = + pixie_context_rounded_rect(ctx, x, y, w, h, nw, ne, se, sw) + +proc pixie_context_ellipse(ctx: Context, x: float32, y: float32, rx: float32, ry: float32) {.importc: "pixie_context_ellipse", cdecl.} + +proc ellipse*(ctx: Context, x: float32, y: float32, rx: float32, ry: float32) {.inline.} = + pixie_context_ellipse(ctx, x, y, rx, ry) + +proc pixie_context_circle(ctx: Context, cx: float32, cy: float32, r: float32) {.importc: "pixie_context_circle", cdecl.} + +proc circle*(ctx: Context, cx: float32, cy: float32, r: float32) {.inline.} = + pixie_context_circle(ctx, cx, cy, r) + +proc pixie_context_polygon(ctx: Context, x: float32, y: float32, size: float32, sides: int) {.importc: "pixie_context_polygon", cdecl.} + +proc polygon*(ctx: Context, x: float32, y: float32, size: float32, sides: int) {.inline.} = + pixie_context_polygon(ctx, x, y, size, sides) + +proc pixie_context_clear_rect(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.importc: "pixie_context_clear_rect", cdecl.} + +proc clearRect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.inline.} = + pixie_context_clear_rect(ctx, x, y, width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_fill_rect(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.importc: "pixie_context_fill_rect", cdecl.} + +proc fillRect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.inline.} = + pixie_context_fill_rect(ctx, x, y, width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_stroke_rect(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.importc: "pixie_context_stroke_rect", cdecl.} + +proc strokeRect*(ctx: Context, x: float32, y: float32, width: float32, height: float32) {.inline.} = + pixie_context_stroke_rect(ctx, x, y, width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_fill_text(ctx: Context, text: cstring, x: float32, y: float32) {.importc: "pixie_context_fill_text", cdecl.} + +proc fillText*(ctx: Context, text: string, x: float32, y: float32) {.inline.} = + pixie_context_fill_text(ctx, text.cstring, x, y) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_stroke_text(ctx: Context, text: cstring, x: float32, y: float32) {.importc: "pixie_context_stroke_text", cdecl.} + +proc strokeText*(ctx: Context, text: string, x: float32, y: float32) {.inline.} = + pixie_context_stroke_text(ctx, text.cstring, x, y) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_translate(ctx: Context, x: float32, y: float32) {.importc: "pixie_context_translate", cdecl.} + +proc translate*(ctx: Context, x: float32, y: float32) {.inline.} = + pixie_context_translate(ctx, x, y) + +proc pixie_context_scale(ctx: Context, x: float32, y: float32) {.importc: "pixie_context_scale", cdecl.} + +proc scale*(ctx: Context, x: float32, y: float32) {.inline.} = + pixie_context_scale(ctx, x, y) + +proc pixie_context_rotate(ctx: Context, angle: float32) {.importc: "pixie_context_rotate", cdecl.} + +proc rotate*(ctx: Context, angle: float32) {.inline.} = + pixie_context_rotate(ctx, angle) + +proc pixie_context_is_point_in_path(ctx: Context, x: float32, y: float32, winding_rule: WindingRule): bool {.importc: "pixie_context_is_point_in_path", cdecl.} + +proc isPointInPath*(ctx: Context, x: float32, y: float32, windingRule: WindingRule): bool {.inline.} = + result = pixie_context_is_point_in_path(ctx, x, y, windingRule) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_context_is_point_in_stroke(ctx: Context, x: float32, y: float32): bool {.importc: "pixie_context_is_point_in_stroke", cdecl.} + +proc isPointInStroke*(ctx: Context, x: float32, y: float32): bool {.inline.} = + result = pixie_context_is_point_in_stroke(ctx, x, y) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_new_image(width: int, height: int): Image {.importc: "pixie_new_image", cdecl.} + +proc newImage*(width: int, height: int): Image {.inline.} = + result = pixie_new_image(width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_new_mask(width: int, height: int): Mask {.importc: "pixie_new_mask", cdecl.} + +proc newMask*(width: int, height: int): Mask {.inline.} = + result = pixie_new_mask(width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_new_paint(kind: PaintKind): Paint {.importc: "pixie_new_paint", cdecl.} + +proc newPaint*(kind: PaintKind): Paint {.inline.} = + result = pixie_new_paint(kind) + +proc pixie_new_path(): Path {.importc: "pixie_new_path", cdecl.} + +proc newPath*(): Path {.inline.} = + result = pixie_new_path() + +proc pixie_new_span(text: cstring, font: Font): Span {.importc: "pixie_new_span", cdecl.} + +proc newSpan*(text: string, font: Font): Span {.inline.} = + result = pixie_new_span(text.cstring, font) + +proc pixie_new_context(width: int, height: int): Context {.importc: "pixie_new_context", cdecl.} + +proc newContext*(width: int, height: int): Context {.inline.} = + result = pixie_new_context(width, height) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_read_image(file_path: cstring): Image {.importc: "pixie_read_image", cdecl.} + +proc readImage*(filePath: string): Image {.inline.} = + result = pixie_read_image(filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_read_mask(file_path: cstring): Mask {.importc: "pixie_read_mask", cdecl.} + +proc readMask*(filePath: string): Mask {.inline.} = + result = pixie_read_mask(filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_read_typeface(file_path: cstring): Typeface {.importc: "pixie_read_typeface", cdecl.} + +proc readTypeface*(filePath: string): Typeface {.inline.} = + result = pixie_read_typeface(filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_read_font(file_path: cstring): Font {.importc: "pixie_read_font", cdecl.} + +proc readFont*(filePath: string): Font {.inline.} = + result = pixie_read_font(filePath.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_parse_path(path: cstring): Path {.importc: "pixie_parse_path", cdecl.} + +proc parsePath*(path: string): Path {.inline.} = + result = pixie_parse_path(path.cstring) + if checkError(): + raise newException(PixieError, $takeError()) + +proc pixie_miter_limit_to_angle(limit: float32): float32 {.importc: "pixie_miter_limit_to_angle", cdecl.} + +proc miterLimitToAngle*(limit: float32): float32 {.inline.} = + result = pixie_miter_limit_to_angle(limit) + +proc pixie_angle_to_miter_limit(angle: float32): float32 {.importc: "pixie_angle_to_miter_limit", cdecl.} + +proc angleToMiterLimit*(angle: float32): float32 {.inline.} = + result = pixie_angle_to_miter_limit(angle) +