@nativescript/canvas 2.0.0-alpha.3 → 2.0.0-alpha.31

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

@@ -5,8 +5,6 @@
 #pragma once
 #pragma process_pending_includes
 
-#import "NativeScript/JSIRuntime.h"
-#include "rust/cxx.h"
 #include <vector>
 #include <cstdint>
 #include <memory>
@@ -14,7 +12,6 @@
 #include "RafImpl.h"
 #include "OnRafCallback.h"
 
-#include "canvas-cxx/src/lib.rs.h"
 #include "Helpers.h"
 
 #include "CanvasGradient.h"
@@ -24,23 +21,277 @@
 #include "ImageAssetImpl.h"
 #include "ImageBitmapImpl.h"
 #include "Path2D.h"
-#include "webgl/WebGLRenderingContextBase.h"
+#include "WebGLRenderingContextBase.h"
+#include "Helpers.h"
 
+class CanvasRenderingContext2DImpl {
+public:
+    CanvasRenderingContext2DImpl(CanvasRenderingContext2D* context);
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
+    static CanvasRenderingContext2DImpl *GetPointer(const v8::Local<v8::Object> &object);
 
-class JSI_EXPORT CanvasRenderingContext2DImpl : public facebook::jsi::HostObject {
-public:
-    CanvasRenderingContext2DImpl(rust::Box<CanvasRenderingContext2D> context);
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    ~CanvasRenderingContext2DImpl();
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, CanvasRenderingContext2DImpl *renderingContext) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = CanvasRenderingContext2DImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::CanvasRenderingContext2D);
+        auto ext = v8::External::New(isolate, renderingContext);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static void DrawPoint(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawPoints(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawPaint(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void __MakeDirty(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __Resize(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFilter(v8::Local<v8::String> property,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetFilter(v8::Local<v8::String> property,
+                          v8::Local<v8::Value> value,
+                          const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetFont(v8::Local<v8::String> property,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetFont(v8::Local<v8::String> property,
+                        v8::Local<v8::Value> value,
+                        const v8::PropertyCallbackInfo<void> &info);
+
+    static void SetGlobalAlpha(v8::Local<v8::String> property,
+                               v8::Local<v8::Value> value,
+                               const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetGlobalAlpha(v8::Local<v8::String> property,
+                               const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+    static void SetImageSmoothingEnabled(v8::Local<v8::String> property,
+                                         v8::Local<v8::Value> value,
+                                         const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetImageSmoothingEnabled(v8::Local<v8::String> property,
+                                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetImageSmoothingQuality(v8::Local<v8::String> property,
+                                         v8::Local<v8::Value> value,
+                                         const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetImageSmoothingQuality(v8::Local<v8::String> property,
+                                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetLineDashOffset(v8::Local<v8::String> property,
+                                  v8::Local<v8::Value> value,
+                                  const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetLineDashOffset(v8::Local<v8::String> property,
+                                  const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLineJoin(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetLineJoin(v8::Local<v8::String> property,
+                            v8::Local<v8::Value> value,
+                            const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetLineCap(v8::Local<v8::String> property,
+                           const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetLineCap(v8::Local<v8::String> property,
+                           v8::Local<v8::Value> value,
+                           const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetMiterLimit(v8::Local<v8::String> property,
+                              const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetMiterLimit(v8::Local<v8::String> property,
+                              v8::Local<v8::Value> value,
+                              const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetShadowColor(v8::Local<v8::String> property,
+                               const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetShadowColor(v8::Local<v8::String> property,
+                               v8::Local<v8::Value> value,
+                               const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetShadowBlur(v8::Local<v8::String> property,
+                              const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetShadowBlur(v8::Local<v8::String> property,
+                              v8::Local<v8::Value> value,
+                              const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetShadowOffsetX(v8::Local<v8::String> property,
+                                 const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetShadowOffsetX(v8::Local<v8::String> property,
+                                 v8::Local<v8::Value> value,
+                                 const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetShadowOffsetY(v8::Local<v8::String> property,
+                                 const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetShadowOffsetY(v8::Local<v8::String> property,
+                                 v8::Local<v8::Value> value,
+                                 const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetTextAlign(v8::Local<v8::String> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetTextAlign(v8::Local<v8::String> property,
+                             v8::Local<v8::Value> value,
+                             const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetGlobalCompositeOperation(v8::Local<v8::String> property,
+                                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetGlobalCompositeOperation(v8::Local<v8::String> property,
+                                            v8::Local<v8::Value> value,
+                                            const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetFillStyle(v8::Local<v8::String> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetFillStyle(v8::Local<v8::String> property,
+                             v8::Local<v8::Value> value,
+                             const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetStrokeStyle(v8::Local<v8::String> property,
+                               const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetStrokeStyle(v8::Local<v8::String> property,
+                               v8::Local<v8::Value> value,
+                               const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetLineWidth(v8::Local<v8::String> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetLineWidth(v8::Local<v8::String> property,
+                             v8::Local<v8::Value> value,
+                             const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetLineDash(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void SetLineDash(v8::Local<v8::String> property,
+                            v8::Local<v8::Value> value,
+                            const v8::PropertyCallbackInfo<void> &info);
 
-    void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void AddHitRegion(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Arc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ArcTo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BeginPath(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BezierCurveTo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearHitRegions(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearRect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Clip(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClosePath(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateImageData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreatePattern(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateLinearGradient(
+            const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateConicGradient(
+            const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __CreatePatternWithNative(
+            const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRadialGradient(
+            const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawFocusIfNeeded(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Ellipse(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Fill(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FillRect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FillText(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetImageData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetLineDash(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsPointInPath(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsPointInStroke(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void LineTo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void MeasureText(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void MoveTo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PutImageData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void QuadraticCurveTo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Rect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RemoveHitRegion(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ResetTransform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Restore(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Rotate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Save(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Scale(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ScrollPathIntoView(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetLineDash(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetTransform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Stroke(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StrokeRect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StrokeText(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Transform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Translate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    ~CanvasRenderingContext2DImpl();
 
     void UpdateInvalidateState();
 
@@ -58,12 +309,12 @@ public:
 
     RafImpl *GetRaf();
 
-    CanvasRenderingContext2D &GetContext();
+    CanvasRenderingContext2D* GetContext();
 
 private:
-    rust::Box<CanvasRenderingContext2D> context_;
+    CanvasRenderingContext2D* context_;
 
-    int invalidateState_ = static_cast<int>(InvalidateState::NONE);
+    int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
 
     std::shared_ptr<RafImpl> raf_;
 

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

@@ -0,0 +1,203 @@
+//
+// Created by Osei Fortune on 27/03/2022.
+//
+
+#include "ImageDataImpl.h"
+#include "Helpers.h"
+#include "Caches.h"
+
+struct ImageDataBuffer {
+public:
+    explicit ImageDataBuffer(ImageData* imageData) : imageData_(imageData) {
+        this->slice_ = canvas_native_image_data_get_data(imageData_);
+        this->buf_ = canvas_native_u8_buffer_get_bytes_mut(slice_);
+        this->size_ = canvas_native_u8_buffer_get_length(slice_);
+    }
+
+    size_t size() const {
+        return this->size_;
+    }
+
+    uint8_t *data() {
+        return this->buf_;
+    }
+
+    ~ImageDataBuffer() {
+        canvas_native_u8_buffer_destroy(slice_);
+        slice_ = nullptr;
+        canvas_native_image_data_destroy(imageData_);
+        imageData_ = nullptr;
+    }
+
+private:
+    uint8_t *buf_;
+    size_t size_;
+    ImageData* imageData_;
+    U8Buffer* slice_;
+};
+
+ImageDataImpl::ImageDataImpl(ImageData* imageData) : imageData_(imageData) {}
+
+void ImageDataImpl::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, "ImageData"), func);
+}
+
+
+ImageDataImpl *ImageDataImpl::GetPointer(const v8::Local<v8::Object>& object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<ImageDataImpl *>(ptr);
+}
+
+
+v8::Local<v8::FunctionTemplate> ImageDataImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->ImageDataTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, Ctor);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageData"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "width"),
+            GetWidth);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "height"),
+            GetHeight);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "data"),
+            GetData);
+    cache->ImageDataTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void ImageDataImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto value = args[0];
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    if (count == 1 && !value->IsString()) {
+        auto label = value->ToString(isolate->GetCurrentContext()).ToLocalChecked();
+        auto arg = ConvertFromV8String(isolate, label);
+        auto error = "Failed to construct 'TextEncoder': The encoding label provided (" +
+                     arg + "') is invalid";
+        isolate->ThrowError(ConvertToV8String(isolate, error));
+        return;
+    }
+
+    auto ret = args.This();
+
+    if (value->IsNumber()) {
+        auto image_data = canvas_native_context_create_image_data(
+                (int32_t) value->NumberValue(context).ToChecked(),
+                (int32_t) args[1]->NumberValue(context).ToChecked());
+        
+        auto object = new ImageDataImpl(image_data);
+
+        auto ext = v8::External::New(isolate, object);
+
+        ret->SetInternalField(0, ext);
+
+        args.GetReturnValue().Set(ret);
+        return;
+
+    } else if (value->IsUint8ClampedArray()) {
+        auto arrayObject = value.As<v8::Uint8ClampedArray>();
+        auto array = arrayObject->Buffer();
+        auto store = array->GetBackingStore();
+        auto buffer_data = static_cast<u_int8_t *>(store->Data()) + arrayObject->ByteOffset();
+        auto len = arrayObject->Length();
+
+
+        auto image_data = canvas_native_context_create_image_data_with_data(
+                (int32_t) args[1]->NumberValue(context).ToChecked(),
+                (int32_t) args[2]->NumberValue(context).ToChecked(), buffer_data, len);
+
+        auto object = new ImageDataImpl(image_data);
+
+        auto ext = v8::External::New(isolate, object);
+
+        ret->SetInternalField(0, ext);
+
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    // TODO throw ?
+    args.GetReturnValue().SetUndefined();
+}
+
+
+void
+ImageDataImpl::GetWidth(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto ret = canvas_native_image_data_get_width(ptr->GetImageData());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+void
+ImageDataImpl::GetHeight(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto ret = canvas_native_image_data_get_height(ptr->GetImageData());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+ImageDataImpl::GetData(v8::Local<v8::String> name,
+                       const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+
+        auto data = new ImageDataBuffer(
+                canvas_native_image_data_get_shared_instance(ptr->GetImageData()));
+
+        auto length = data->size();
+        auto store = v8::ArrayBuffer::NewBackingStore(data->data(), length,
+                                                      [](void *data, size_t length,
+                                                         void *deleter_data) {
+                                                          if (deleter_data != nullptr) {
+                                                              delete (ImageDataBuffer *) deleter_data;
+                                                          }
+                                                      },
+                                                      data);
+
+        auto buf = v8::ArrayBuffer::New(isolate, std::move(store));
+
+        auto ret = v8::Uint8ClampedArray::New(buf, 0, length);
+
+
+        info.GetReturnValue().Set(ret);
+
+        return;
+    }
+    info.GetReturnValue().SetUndefined();
+}

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

@@ -4,26 +4,40 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
 #include <vector>
+#include "Common.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
 
-class JSI_EXPORT ImageDataImpl : public jsi::HostObject {
+class ImageDataImpl {
 public:
-    ImageDataImpl(rust::Box<ImageData> imageData);
+    ImageDataImpl(ImageData* imageData);
+    
+    ~ImageDataImpl(){
+        canvas_native_image_data_destroy(this->GetImageData());
+        this->imageData_ = nullptr;
+    }
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static ImageDataImpl *GetPointer(const 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 GetWidth(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void GetHeight(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetData(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    ImageData &GetImageData() {
-        return *this->imageData_;
+    ImageData* GetImageData() {
+        return this->imageData_;
     }
 
 private:
-    rust::Box<ImageData> imageData_;
+    ImageData* imageData_;
 };