fixes, updates (#25)

Author: DjDeveloperr

README.md

@@ -68,6 +68,8 @@ For non-standard APIs, refer to the API docs mentioned above.
 - `Fonts` - provides utility to manage fonts used by Skia
 - `PdfDocument` - create PDF documents using 2D Canvas API
 - `SvgCanvas` - like `Canvas` but creates an SVG as output instead
+- Several additional methods in `Path2D` object such as `toSVGString`,
+  `simplify`, `difference`, `xor`, etc.
 
 ## Benchmarks
 

native/include/path2d.hpp

@@ -1,8 +1,11 @@
 #pragma once
 
+#include "include/core/SkString.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkPaint.h"
 #include "include/utils/SkParsePath.h"
 #include "include/core/SkMatrix.h"
+#include "include/pathops/SkPathOps.h"
 #include "include/common.hpp"
 
 extern "C" {
@@ -20,5 +23,12 @@ extern "C" {
   SKIA_EXPORT void sk_path_arc(SkPath* path, float x, float y, float radius, float startAngle, float endAngle, bool clockwise);
   SKIA_EXPORT void sk_path_bezier_curve_to(SkPath* path, float cp1x, float cp1y, float cp2x, float cp2y, float x, float y);
   SKIA_EXPORT void sk_path_quadratic_curve_to(SkPath* path, float cpx, float cpy, float x, float y);
+  SKIA_EXPORT int sk_path_is_point_in_path(SkPath* path, float x, float y, int rule);
+  SKIA_EXPORT int sk_path_is_point_in_stroke(SkPath* path, float x, float y, float strokeWidth);
+  SKIA_EXPORT SkString* sk_path_to_svg(SkPath* path, const char** outString, int* outSize);
+  SKIA_EXPORT void sk_free_string(SkString* str);
+  SKIA_EXPORT int sk_path_simplify(SkPath* path);
+  SKIA_EXPORT int sk_path_as_winding(SkPath* path);
+  SKIA_EXPORT int sk_path_op(SkPath* p1, SkPath* p2, int op);
   SKIA_EXPORT void sk_path_destroy(SkPath* path);
 }

native/src/context2d.cpp

@@ -863,14 +863,13 @@ extern "C" {
   // Context.isPointInPath()
   int sk_context_is_point_in_path(sk_context* context, float x, float y, SkPath* path, int rule) {
     if (path == nullptr) path = context->path;
-    path->setFillType(rule == 1 ? SkPathFillType::kEvenOdd : SkPathFillType::kWinding);
-    return (int) path->contains(x, y);
+    return sk_path_is_point_in_path(path, x, y, rule);
   }
 
   // Context.isPointInStroke()
   int sk_context_is_point_in_stroke(sk_context* context, float x, float y, SkPath* path) {
     if (path == nullptr) path = context->path;
-    return (int) path->contains(x, y);
+    return sk_path_is_point_in_stroke(path, x, y, context->state->paint->getStrokeWidth());
   }
 
   /// Transformations
@@ -1085,6 +1084,10 @@ extern "C" {
       context->state->paint,
       SkCanvas::kFast_SrcRectConstraint
     );
+
+    if (canvas != nullptr) {
+      image->unref();
+    }
   }
 
   /// Pixel manipulation

native/src/path2d.cpp

@@ -114,6 +114,55 @@ extern "C" {
     path->quadTo(cpx, cpy, x, y);
   }
 
+  int sk_path_is_point_in_path(SkPath* path, float x, float y, int rule) {
+    auto prev = path->getFillType();
+    path->setFillType(rule == 1 ? SkPathFillType::kEvenOdd : SkPathFillType::kWinding);
+    auto result = (int) path->contains(x, y);
+    path->setFillType(prev);
+    return result;
+  }
+
+  int sk_path_is_point_in_stroke(SkPath* path, float x, float y, float strokeWidth) {
+    auto prev = path->getFillType();
+    path->setFillType(SkPathFillType::kWinding);
+    SkPaint paint;
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(strokeWidth);
+    SkPath traced;
+    int result;
+    if (paint.getFillPath(*path, &traced, nullptr, 0.3)) {
+      result = (int)traced.contains(x, y);
+    } else {
+      result = (int)path->contains(x, y);
+    }
+    path->setFillType(prev);
+    return result;
+  }
+
+  SkString* sk_path_to_svg(SkPath* path, const char** outString, int* outSize) {
+    auto string = new SkString();
+    SkParsePath::ToSVGString(*path, string);
+    *outString = string->c_str();
+    *outSize = string->size();
+    return string;
+  }
+
+  int sk_path_simplify(SkPath* path) {
+    return (int) Simplify(*path, path);
+  }
+
+  int sk_path_as_winding(SkPath* path) {
+    return (int) AsWinding(*path, path);
+  }
+
+  int sk_path_op(SkPath* p1, SkPath* p2, int op) {
+    return (int) Op(*p1, *p2, (SkPathOp)op, p1);
+  }
+
+  void sk_free_string(SkString* str) {
+    delete str;
+  }
+
   void sk_path_destroy(SkPath* path) {
     delete path;
   }

src/canvas.ts

@@ -132,11 +132,18 @@ export class Canvas {
 
     const size = OUT_SIZE[0];
     const ptr = OUT_DATA[0];
-    const buffer = new Uint8Array(getBuffer(bufptr, size));
+    const buffer = new Uint8Array(getBuffer(bufptr, 0, size));
     SK_DATA_FINALIZER.register(buffer, ptr);
     return buffer;
   }
 
+  toDataURL(format: ImageFormat = "png", quality = 100) {
+    const buffer = this.encode(format, quality);
+    return `data:image/${format};base64,${
+      (Deno as any).core.ops.op_base64_encode(buffer)
+    }`;
+  }
+
   /**
    * Read pixels from the canvas into a buffer.
    */

src/context2d.ts

@@ -970,6 +970,9 @@ export class CanvasRenderingContext2D {
     asw?: number,
     ash?: number,
   ) {
+    if (image instanceof Image && image._unsafePointer === 0) {
+      return;
+    }
     const dx = asx ?? adx;
     const dy = asy ?? ady;
     const dw = asw ?? adw ?? image.width;

src/ffi.ts

@@ -833,6 +833,41 @@ const SYMBOLS = {
     parameters: ["pointer", "i32", "i32"],
     result: "void",
   },
+
+  sk_path_is_point_in_path: {
+    parameters: ["pointer", "f32", "f32", "i32"],
+    result: "i32",
+  },
+
+  sk_path_is_point_in_stroke: {
+    parameters: ["pointer", "f32", "f32", "f32"],
+    result: "i32",
+  },
+
+  sk_path_to_svg: {
+    parameters: ["pointer", "buffer", "buffer"],
+    result: "pointer",
+  },
+
+  sk_free_string: {
+    parameters: ["pointer"],
+    result: "void",
+  },
+
+  sk_path_simplify: {
+    parameters: ["pointer"],
+    result: "i32",
+  },
+
+  sk_path_as_winding: {
+    parameters: ["pointer"],
+    result: "i32",
+  },
+
+  sk_path_op: {
+    parameters: ["pointer", "pointer", "i32"],
+    result: "i32",
+  },
 } as const;
 
 const LOCAL_BUILD = Deno.env.get("DENO_SKIA_LOCAL") === "1";
@@ -919,7 +954,11 @@ const {
   op_ffi_get_buf,
 }: {
   op_ffi_cstr_read: (ptr: Deno.PointerValue) => string;
-  op_ffi_get_buf: (ptr: Deno.PointerValue, size: number) => ArrayBuffer;
+  op_ffi_get_buf: (
+    ptr: Deno.PointerValue,
+    offset: number,
+    size: number,
+  ) => ArrayBuffer;
 } = (Deno as any).core.ops;
 
 export function cstr(str: string) {

src/image.ts

@@ -14,21 +14,120 @@ const SK_IMAGE_FINALIZER = new FinalizationRegistry(
   },
 );
 
-export class Image {
-  #ptr: Deno.PointerValue;
+export type ImageSource = Uint8Array | string;
+
+export class Image extends EventTarget {
+  #token: { ptr: Deno.PointerValue } = { ptr: 0 };
+  #ptr: Deno.PointerValue = 0;
+  #src?: ImageSource;
 
   get _unsafePointer() {
     return this.#ptr;
   }
 
-  constructor(data: Uint8Array | string) {
+  constructor(data?: ImageSource) {
+    super();
+    this.src = data;
+  }
+
+  get src() {
+    return this.#src;
+  }
+
+  set src(data: ImageSource | undefined) {
+    if (this.#ptr !== 0) {
+      sk_image_destroy(this.#ptr);
+      SK_IMAGE_FINALIZER.unregister(this.#token);
+      this.#ptr = 0;
+    }
+
+    if (data === undefined) {
+      this.#src = undefined;
+      this.#ptr = 0;
+      this.#token.ptr = 0;
+      return;
+    }
+
+    if (typeof data === "string") {
+      if (data.match(/^\s*https?:\/\//)) {
+        fetch(data.trim())
+          .then((res) => res.arrayBuffer())
+          .then((buffer) => {
+            this.src = new Uint8Array(buffer);
+          })
+          .catch((error) => {
+            this.dispatchEvent(
+              new ErrorEvent("error", {
+                error,
+              }),
+            );
+          });
+        return;
+      } else if (data.match(/^\s*data:/)) {
+        const comma = data.indexOf(",");
+        const isBase64 = data.lastIndexOf("base64", comma) !== -1;
+        const content = data.slice(comma + 1);
+        const buffer = isBase64
+          ? (Deno as any).core.ops.op_base64_decode(content)
+          : new TextEncoder().encode(content);
+        this.src = buffer;
+        return;
+      }
+    }
+
     this.#ptr = data instanceof Uint8Array
       ? sk_image_from_encoded(data, data.byteLength)
       : sk_image_from_file(cstr(data));
+
     if (this.#ptr === 0) {
-      throw new Error("Failed to load image");
+      const error = new Error("Failed to load image");
+      queueMicrotask(() => {
+        this.dispatchEvent(
+          new ErrorEvent("error", {
+            error,
+          }),
+        );
+      });
+      throw error;
+    }
+
+    this.#token.ptr = this.#ptr;
+    this.#src = data;
+
+    if (this.#ptr !== 0) {
+      SK_IMAGE_FINALIZER.register(this, this.#ptr, this.#token);
+    }
+
+    queueMicrotask(() => {
+      this.dispatchEvent(new Event("load"));
+    });
+  }
+
+  #onload?: EventListenerOrEventListenerObject;
+  #onerror?: EventListenerOrEventListenerObject;
+
+  get onload() {
+    return this.#onload;
+  }
+
+  get onerror() {
+    return this.#onerror;
+  }
+
+  set onload(fn: EventListenerOrEventListenerObject | undefined) {
+    if (this.#onload) {
+      this.removeEventListener("load", this.#onload);
     }
-    SK_IMAGE_FINALIZER.register(this, this.#ptr);
+    this.#onload = fn;
+    if (fn) this.addEventListener("load", fn);
+  }
+
+  set onerror(fn: EventListenerOrEventListenerObject | undefined) {
+    if (this.#onerror) {
+      this.removeEventListener("error", this.#onerror);
+    }
+    this.#onerror = fn;
+    if (fn) this.addEventListener("error", fn);
   }
 
   static async load(path: string | URL) {
@@ -49,14 +148,19 @@ export class Image {
   }
 
   get width() {
+    if (this._unsafePointer === 0) return 0;
     return sk_image_width(this.#ptr);
   }
 
   get height() {
+    if (this._unsafePointer === 0) return 0;
     return sk_image_height(this.#ptr);
   }
 
   [Symbol.for("Deno.customInspect")]() {
+    if (this._unsafePointer === 0) {
+      return `Image { pending, src: ${Deno.inspect(this.src)} }`;
+    }
     return `Image { width: ${this.width}, height: ${this.height} }`;
   }
 }