@nativescript/canvas 2.0.0-beta.2 → 2.0.0-beta.20

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

@@ -28,6 +28,10 @@
 class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 public:
 
+    static v8::CFunction fast_start_raf_;
+
+    static v8::CFunction fast_stop_raf_;
+
     static v8::CFunction fast_draw_point_;
 
     static v8::CFunction fast_arc_;
@@ -102,12 +106,16 @@ public:
 
     static v8::CFunction fast_fill_rect_;
 
+    static v8::CFunction fast_fill_oval_;
+
     static v8::CFunction fast_stroke_;
 
     static v8::CFunction fast_stroke_path_;
 
     static v8::CFunction fast_stroke_rect_;
 
+    static v8::CFunction fast_stroke_oval_;
+
     static v8::CFunction fast_rotate_;
 
     static v8::CFunction fast_reset_transform_;
@@ -118,9 +126,39 @@ public:
 
     static v8::CFunction fast_translate_;
 
+    static v8::CFunction fast_draw_atlas_;
+
 
     CanvasRenderingContext2DImpl(CanvasRenderingContext2D *context);
 
+    void StartRaf();
+
+    void StopRaf();
+
+    static void __StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStartRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StartRaf();
+
+    }
+
+    static void __StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStopRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StopRaf();
+
+    }
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static CanvasRenderingContext2DImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -163,6 +201,15 @@ public:
 
     static void __Resize(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                        v8::Local<v8::Value> value,
+                                        const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
     static void GetFilter(v8::Local<v8::String> property,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
@@ -489,18 +536,10 @@ public:
 
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_clip(
-                            ptr->GetContext(), path->GetPath(), rule);
-                    break;
-                default:
-                    break;
-            }
+            canvas_native_context_clip(
+                    ptr->GetContext(), path->GetPath(), rule);
         }
 
-
     }
 
     static void ClosePath(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -536,6 +575,51 @@ public:
 
     static void DrawFocusIfNeeded(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void DrawAtlas(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+/*
+    static void FastDrawAtlas(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> image_obj, v8::Local<v8::Array> xform, v8::Local<v8::Array> tex, v8::Local<v8::Array> xform) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto len = array->Length();
+        std::vector<float> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                array, buf.data(), len);
+
+        if (copied) {
+
+        auto imageType = GetNativeType(image_obj);
+        switch (imageType) {
+            case NativeType::ImageAsset: {
+                auto asset = ImageAssetImpl::GetPointer(image_obj);
+
+            }
+                break;
+            case NativeType::ImageBitmap: {
+                auto asset = ImageBitmapImpl::GetPointer(image_obj);
+            }
+                break;
+            case NativeType::CanvasRenderingContext2D: {
+                auto context = CanvasRenderingContext2DImpl::GetPointer(image_obj);
+
+            }
+                break;
+            default:
+                break;
+        }
+
+
+        ptr->UpdateInvalidateState();
+    }
+        */
+
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
@@ -800,18 +884,10 @@ public:
         auto object = Path2D::GetPointer(path);
 
         if (object != nullptr) {
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_fill_with_path(
-                            ptr->GetContext(),
-                            object->GetPath(),
-                            rule);
-                    break;
-                default:
-                    break;
-            }
-
+            canvas_native_context_fill_with_path(
+                    ptr->GetContext(),
+                    object->GetPath(),
+                    rule);
             ptr->UpdateInvalidateState();
         }
     }
@@ -837,16 +913,9 @@ public:
             return;
         }
 
-        switch (rule) {
-            case 0:
-            case 1:
-                canvas_native_context_fill(
-                        ptr->GetContext(), rule);
-                ptr->UpdateInvalidateState();
-                break;
-            default:
-                break;
-        }
+        canvas_native_context_fill(
+                ptr->GetContext(), rule);
+        ptr->UpdateInvalidateState();
     }
 
     static void FastFill(v8::Local<v8::Object> receiver_obj) {
@@ -882,6 +951,27 @@ public:
 
     static void FillText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void FillOval(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void FastFillOval(v8::Local<v8::Object> receiver_obj, double x, double y, double width,
+                             double height) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_context_fill_oval(
+                ptr->GetContext(),
+                static_cast<float>(x),
+                static_cast<float>(y),
+                static_cast<float>(width),
+                static_cast<float>(height)
+        );
+        ptr->UpdateInvalidateState();
+    }
+
     static void GetImageData(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void GetLineDash(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -907,18 +997,8 @@ public:
             return false;
         }
 
-        bool ret = false;
-        switch (rule) {
-            case 0:
-            case 1:
-                ret = canvas_native_context_is_point_in_path(
-                        ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
-                break;
-            default:
-                break;
-        }
-
-        return ret;
+        return canvas_native_context_is_point_in_path(
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
     }
 
     static bool
@@ -939,17 +1019,9 @@ public:
             auto path = Path2D::GetPointer(path_obj);
 
 
-            switch (rule) {
-                case 0:
-                case 1:
-                    ret = canvas_native_context_is_point_in_path_with_path(
-                            ptr->GetContext(),
-                            path->GetPath(), x, y, rule);
-                    break;
-                    break;
-                default:
-                    break;
-            }
+            ret = canvas_native_context_is_point_in_path_with_path(
+                    ptr->GetContext(),
+                    path->GetPath(), x, y, rule);
 
         }
         return ret;
@@ -1325,6 +1397,27 @@ public:
 
     static void StrokeText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+
+    static void StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void FastStrokeOval(v8::Local<v8::Object> receiver_obj, double x, double y, double width,
+                               double height) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_context_stroke_oval(
+                ptr->GetContext(), static_cast<float>(x),
+                static_cast<float>(y),
+                static_cast<float>(width),
+                static_cast<float>(height));
+        ptr->UpdateInvalidateState();
+    }
+
+
     static void Transform(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
@@ -1385,4 +1478,6 @@ private:
 
     std::shared_ptr<RafImpl> raf_;
 
+    bool continuousRender_ = true;
+
 };