@nativescript/canvas 2.0.0-alpha.9 → 2.0.0-beta.1

package/platforms/ios/src/cpp/canvas2d/MatrixImpl.h

@@ -4,26 +4,186 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
 #include <vector>
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT MatrixImpl : public jsi::HostObject {
+class MatrixImpl: public ObjectWrapperImpl {
 public:
-    MatrixImpl(rust::Box<Matrix> matrix);
+    MatrixImpl(Matrix* matrix);
+    ~MatrixImpl(){
+        canvas_native_matrix_destroy(this->GetMatrix());
+        this->matrix_ = nullptr;
+    }
+
+    Matrix* GetMatrix();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static MatrixImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetA(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetA(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+
+    static void GetB(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetB(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetC(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetC(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetD(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetD(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetE(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetE(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetF(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetF(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+
+    static void GetM11(v8::Local<v8::String> property,
+                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM11(v8::Local<v8::String> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void> &info);
+
+
+    static void GetM12(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM12(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+
+    static void GetM13(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM13(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM14(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM14(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM21(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM21(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM22(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM22(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM23(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM23(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM24(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM24(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM31(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM31(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM32(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM32(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM33(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM33(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM34(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM34(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM41(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM41(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetM42(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetM42(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void GetM43(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
+    static void SetM43(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetM44(v8::Local<v8::String> property,
+                       const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    Matrix &GetMatrix();
+    static void SetM44(v8::Local<v8::String> property,
+                       v8::Local<v8::Value> value,
+                       const v8::PropertyCallbackInfo<void> &info);
 
 private:
-    rust::Box<Matrix> matrix_;
+    Matrix* matrix_;
 };

package/platforms/ios/src/cpp/canvas2d/Path2D.cpp

@@ -0,0 +1,499 @@
+//
+// Created by Osei Fortune on 28/03/2022.
+//
+
+#include "Path2D.h"
+#include "Caches.h"
+#include "Helpers.h"
+#include "OneByteStringResource.h"
+
+Path2D::Path2D(Path *path)
+        : path_(path) {}
+
+
+void Path2D::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "Path2D"), func);
+}
+
+Path2D *Path2D::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<Path2D *>(ptr);
+}
+
+v8::CFunction Path2D::fast_arc_(v8::CFunction::Make(Path2D::FastArc));
+
+v8::CFunction Path2D::fast_add_path_(v8::CFunction::Make(Path2D::FastAddPath));
+
+v8::CFunction Path2D::fast_arc_to_(v8::CFunction::Make(Path2D::FastArcTo));
+
+v8::CFunction Path2D::fast_bezier_curve_to_(v8::CFunction::Make(Path2D::FastBezierCurveTo));
+
+v8::CFunction Path2D::fast_close_path_(v8::CFunction::Make(Path2D::FastClosePath));
+
+v8::CFunction Path2D::fast_ellipse_(v8::CFunction::Make(Path2D::FastEllipse));
+
+v8::CFunction Path2D::fast_line_to_(v8::CFunction::Make(Path2D::FastLineTo));
+
+v8::CFunction Path2D::fast_move_to_(v8::CFunction::Make(Path2D::FastMoveTo));
+
+v8::CFunction Path2D::fast_quadratic_curve_to_(v8::CFunction::Make(Path2D::FastQuadraticCurveTo));
+
+v8::CFunction Path2D::fast_rect_(v8::CFunction::Make(Path2D::FastRect));
+
+//v8::CFunction Path2D::fast_round_rect_(v8::CFunction::Make(Path2D::FastRoundRect));
+
+
+v8::CFunction Path2D::fast_round_rect_(
+        v8::CFunction::Make(Path2D::FastRoundRect));
+
+v8::CFunction Path2D::fast_round_rect_array_(
+        v8::CFunction::Make(Path2D::FastRoundRectArray));
+
+const v8::CFunction fast_round_rect_overloads_[] = {
+        Path2D::fast_round_rect_,
+        Path2D::fast_round_rect_array_
+};
+
+
+
+//v8::CFunction Path2D::fast_to_svg_(v8::CFunction::Make(Path2D::FastToSVG));
+
+void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto value = args[0];
+    auto isolate = args.GetIsolate();
+
+    auto ret = args.This();
+
+    SetNativeType( ret, NativeType::Path2D);
+
+    if (count > 0) {
+        if (value->IsString()) {
+            auto d = ConvertFromV8String(isolate, value);
+            auto path = canvas_native_path_create_with_string(d.c_str());
+            auto object = new Path2D(path);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+
+            return;
+
+        } else if (value->IsObject()) {
+            auto path_to_copy = GetPointer(value.As<v8::Object>());
+            if (path_to_copy != nullptr) {
+                auto path = canvas_native_path_create_with_path(
+                        path_to_copy->GetPath());
+                auto object = new Path2D(path);
+
+                ret->SetAlignedPointerInInternalField(0, object);
+
+                object->BindFinalizer(isolate, ret);
+
+                args.GetReturnValue().Set(ret);
+                return;
+            }
+        }
+    } else {
+        auto path = new Path2D(canvas_native_path_create());
+
+
+        ret->SetAlignedPointerInInternalField(0, path);
+
+        path->BindFinalizer(isolate, ret);
+
+        args.GetReturnValue().Set(ret);
+        return;
+
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::AddPath(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto value = args[0];
+    if (value->IsObject()) {
+        auto object = GetPointer(value.As<v8::Object>());
+        if (object != nullptr) {
+            AddPathImpl(ptr->GetPath(),
+                        object->GetPath());
+        }
+    }
+}
+
+void Path2D::Arc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto anti_clockwise = false;
+    if (args.Length() == 6) {
+        anti_clockwise = args[5]->BooleanValue(isolate);
+    }
+
+    canvas_native_path_arc(
+            ptr->GetPath(),
+            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[1]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[2]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[3]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[4]->NumberValue(context).ToChecked()),
+            anti_clockwise
+    );
+
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::ArcTo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    ArcToImpl(
+            ptr->GetPath(),
+            args[0]->NumberValue(context).ToChecked(),
+            args[1]->NumberValue(context).ToChecked(),
+            args[2]->NumberValue(context).ToChecked(),
+            args[3]->NumberValue(context).ToChecked(),
+            args[4]->NumberValue(context).ToChecked()
+    );
+}
+
+void Path2D::BezierCurveTo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    BezierCurveToImpl(
+            ptr->GetPath(),
+            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[1]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[2]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[3]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[4]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[5]->NumberValue(context).ToChecked())
+    );
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::ClosePath(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    canvas_native_path_close_path(ptr->GetPath());
+}
+
+void Path2D::Ellipse(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto anti_clockwise = false;
+    if (args.Length() > 7) {
+        anti_clockwise = args[7]->BooleanValue(isolate);
+    }
+
+    canvas_native_path_ellipse(
+            ptr->GetPath(),
+            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[1]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[2]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[3]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[4]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[5]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[6]->NumberValue(context).ToChecked()),
+            anti_clockwise
+    );
+
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::LineTo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    canvas_native_path_line_to(ptr->GetPath(),
+                               static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+                               static_cast<float>(args[1]->NumberValue(context).ToChecked()));
+
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::MoveTo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    canvas_native_path_move_to(ptr->GetPath(),
+                               static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+                               static_cast<float>(args[1]->NumberValue(context).ToChecked()));
+
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::QuadraticCurveTo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    canvas_native_path_quadratic_curve_to(
+            ptr->GetPath(),
+            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[1]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[2]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[3]->NumberValue(context).ToChecked())
+    );
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::Rect(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    canvas_native_path_rect(
+            ptr->GetPath(),
+            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[1]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[2]->NumberValue(context).ToChecked()),
+            static_cast<float>(args[3]->NumberValue(context).ToChecked())
+    );
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    if (args.Length() == 5) {
+        auto x = static_cast<float>(args[0]->NumberValue(context).ToChecked());
+        auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
+        auto width = static_cast<float>(args[2]->NumberValue(context).ToChecked());
+        auto height = static_cast<float>(args[3]->NumberValue(context).ToChecked());
+        auto objectOrNumber = args[4];
+        if (objectOrNumber->IsObject()) {
+            auto radii = objectOrNumber.As<v8::Object>();
+            if (radii->IsArray()) {
+                auto array = radii.As<v8::Array>();
+                auto size = array->Length();
+
+                if (size > 1) {
+                    std::vector<float> store;
+                    store.reserve(size);
+                    for (int i = 0;
+                         i < size; i++) {
+                        store[i] = (float) array->Get(context, i).ToLocalChecked()->NumberValue(
+                                context).ToChecked();
+                    }
+
+                    canvas_native_path_round_rect(
+                            ptr->GetPath(),
+                            x, y,
+                            width,
+                            height, store.data(),
+                            store.size());
+
+                }
+            }
+        } else {
+            auto radii = (float) objectOrNumber->NumberValue(context).ToChecked();
+            canvas_native_path_round_rect_tl_tr_br_bl(
+                    ptr->GetPath(), x, y,
+                    width,
+                    height, radii, radii,
+                    radii, radii);
+
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void Path2D::__toSVG(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto d = canvas_native_path_to_string(
+            ptr->GetPath());
+
+//    args.GetReturnValue().Set(ConvertToV8String(isolate, d.c_str()));
+
+    auto value = new OneByteStringResource((char *) d);
+    auto ret = v8::String::NewExternalOneByte(isolate, value);
+    args.GetReturnValue().Set(ret.ToLocalChecked());
+}
+
+Path *Path2D::GetPath() {
+    return this->path_;
+}
+
+
+v8::Local<v8::FunctionTemplate> Path2D::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->Path2DTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, Ctor);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "Path2D"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "arcTo"),
+            v8::FunctionTemplate::New(isolate, &ArcTo));
+
+    SetFastMethod(isolate, tmpl, "addPath", AddPath, &fast_add_path_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "arc", Arc, &fast_arc_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "arcTo", ArcTo, &fast_arc_to_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "bezierCurveTo", BezierCurveTo, &fast_bezier_curve_to_,
+                  v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "closePath", ClosePath, &fast_close_path_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "ellipse", Ellipse, &fast_ellipse_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "lineTo", LineTo, &fast_line_to_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "moveTo", MoveTo, &fast_move_to_, v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "quadraticCurveTo", QuadraticCurveTo, &fast_quadratic_curve_to_,
+                  v8::Local<v8::Value>());
+    SetFastMethod(isolate, tmpl, "rect", Rect, &fast_rect_, v8::Local<v8::Value>());
+    SetFastMethodWithOverLoads(isolate, tmpl, "roundRect", RoundRect,
+                               fast_round_rect_overloads_, v8::Local<v8::Value>());
+
+    //    tmpl->Set(
+//            ConvertToV8String(isolate, "addPath"),
+//            v8::FunctionTemplate::New(isolate, &AddPath));
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "arc"),
+//            v8::FunctionTemplate::New(isolate, &Arc));
+
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "bezierCurveTo"),
+//            v8::FunctionTemplate::New(isolate, &BezierCurveTo));
+
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "closePath"),
+//            v8::FunctionTemplate::New(isolate, &ClosePath));
+
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "ellipse"),
+//            v8::FunctionTemplate::New(isolate, &Ellipse));
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "lineTo"),
+//            v8::FunctionTemplate::New(isolate, &LineTo));
+
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "moveTo"),
+//            v8::FunctionTemplate::New(isolate, &MoveTo));
+
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "quadraticCurveTo"),
+//            v8::FunctionTemplate::New(isolate, &QuadraticCurveTo));
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "rect"),
+//            v8::FunctionTemplate::New(isolate, &Rect));
+
+//    tmpl->Set(
+//            ConvertToV8String(isolate, "roundRect"),
+//            v8::FunctionTemplate::New(isolate, &RoundRect));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "__toSVG"),
+            v8::FunctionTemplate::New(isolate, &__toSVG));
+
+
+    cache->Path2DTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}