@nativescript/canvas 2.0.0-alpha.8 → 2.0.0-beta.0

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

@@ -3,26 +3,42 @@
 //
 
 #pragma once
-
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
 #include <vector>
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace ::org::nativescript::canvas;
-
-class JSI_EXPORT CanvasGradient : public jsi::HostObject {
+class CanvasGradient: ObjectWrapperImpl {
 public:
-    CanvasGradient(rust::Box<PaintStyle> style);
+    CanvasGradient(PaintStyle*style);
+
+    ~CanvasGradient(){
+        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        this->style_ = nullptr;
+    }
+
+    PaintStyle * GetPaintStyle();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static CanvasGradient *GetPointer(const v8::Local<v8::Object> &object);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasGradient *gradient) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = CanvasGradient::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::CanvasGradient);
+        object->SetAlignedPointerInInternalField(0, gradient);
+        gradient->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
 
-    PaintStyle &GetPaintStyle();
+    static void AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<PaintStyle> style_;
+    PaintStyle* style_;
 };
 

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

@@ -0,0 +1,89 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "CanvasPattern.h"
+#include "Helpers.h"
+#include "Caches.h"
+
+CanvasPattern::CanvasPattern(PaintStyle *style) : style_(style) {}
+
+void CanvasPattern::Init(const 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, "CanvasPattern"), func);
+}
+
+v8::CFunction CanvasPattern::fast_set_transform_(
+        v8::CFunction::Make(CanvasPattern::FastSetTransform));
+
+CanvasPattern *CanvasPattern::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<CanvasPattern *>(ptr);
+}
+
+static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasPattern *pattern) {
+    auto context = isolate->GetCurrentContext();
+    v8::EscapableHandleScope scope(isolate);
+    auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
+            context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+    SetNativeType(object, NativeType::CanvasPattern);
+    object->SetAlignedPointerInInternalField(0, pattern);
+    return scope.Escape(object);
+}
+
+v8::Local<v8::FunctionTemplate> CanvasPattern::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->CanvasPatternTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "CanvasPattern"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    SetFastMethod(isolate, tmpl, "setTransform", SetTransform, &fast_set_transform_,
+                  v8::Local<v8::Value>());
+
+    cache->CanvasPatternTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void CanvasPattern::SetTransform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasPattern *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto value = args[0];
+    auto type = GetNativeType(value);
+
+    if (type == NativeType::Matrix) {
+
+        auto matrix = MatrixImpl::GetPointer(value.As<v8::Object>());
+        if (matrix != nullptr) {
+            canvas_native_pattern_set_transform(
+                    ptr->GetPaintStyle(),
+                    matrix->GetMatrix());
+        }
+    }
+
+}
+
+PaintStyle *CanvasPattern::GetPaintStyle() {
+    return this->style_;
+}

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

@@ -4,26 +4,63 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
 #include "MatrixImpl.h"
 #include <vector>
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT CanvasPattern : public jsi::HostObject {
+class CanvasPattern : ObjectWrapperImpl {
 public:
-    CanvasPattern(rust::Box<PaintStyle> style);
+    CanvasPattern(PaintStyle *style);
+
+    ~CanvasPattern() {
+        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        this->style_ = nullptr;
+    }
+
+    PaintStyle *GetPaintStyle();
+
+    static v8::CFunction fast_set_transform_;
+
+    static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
+
+    static CanvasPattern *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasPattern *pattern) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::CanvasPattern);
+        object->SetAlignedPointerInInternalField(0, pattern);
+        pattern->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void SetTransform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastSetTransform(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> matrix_obj) {
+        CanvasPattern *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        auto type = GetNativeType(matrix_obj);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        if (type == NativeType::Matrix) {
+            auto matrix = MatrixImpl::GetPointer(matrix_obj);
+            if (matrix != nullptr) {
+                canvas_native_pattern_set_transform(
+                        ptr->GetPaintStyle(),
+                        matrix->GetMatrix());
+            }
+        }
 
-    PaintStyle &GetPaintStyle();
+    }
 
 private:
-    rust::Box<PaintStyle> style_;
+    PaintStyle *style_;
 };