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

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

@@ -183,6 +183,71 @@ v8::Local<v8::FunctionTemplate> MatrixImpl::GetCtor(v8::Isolate *isolate) {
     );
 
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "translate"),
+            v8::FunctionTemplate::New(isolate, Translate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "translateSelf"),
+            v8::FunctionTemplate::New(isolate, TranslateSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "multiplySelf"),
+            v8::FunctionTemplate::New(isolate, MultiplySelf)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "premultiplySelf"),
+            v8::FunctionTemplate::New(isolate, PremultiplySelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "scaleNonUniform"),
+            v8::FunctionTemplate::New(isolate, ScaleNonUniform)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "scaleNonUniformSelf"),
+            v8::FunctionTemplate::New(isolate, ScaleNonUniformSelf)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "rotate"),
+            v8::FunctionTemplate::New(isolate, Rotate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "rotateSelf"),
+            v8::FunctionTemplate::New(isolate, RotateSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewX"),
+            v8::FunctionTemplate::New(isolate, SkewX)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewXSelf"),
+            v8::FunctionTemplate::New(isolate, SkewXSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewY"),
+            v8::FunctionTemplate::New(isolate, SkewY)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewYSelf"),
+            v8::FunctionTemplate::New(isolate, SkewYSelf)
+    );
+
+
     cache->MatrixTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
@@ -216,7 +281,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType( ret, NativeType::Matrix);
+                SetNativeType(ret, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -242,7 +307,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType( ret, NativeType::Matrix);
+                SetNativeType(ret, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -257,7 +322,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         ret->SetAlignedPointerInInternalField(0, object);
 
-        SetNativeType( ret, NativeType::Matrix);
+        SetNativeType(ret, NativeType::Matrix);
 
         object->BindFinalizer(isolate, ret);
 
@@ -802,6 +867,347 @@ void MatrixImpl::SetM44(v8::Local<v8::String> property,
     canvas_native_matrix_set_m44(ptr->GetMatrix(), (float) value->NumberValue(context).ToChecked());
 }
 
+
+void MatrixImpl::Translate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 3) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+        auto value = args[2];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_translate(
+                    (float) x->NumberValue(context).ToChecked(),
+                    (float) y->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(ret, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::TranslateSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+
+        canvas_native_matrix_translate_self(ptr->GetMatrix(),
+                                            (float) x->NumberValue(context).ToChecked(),
+                                            (float) y->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::MultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto value = args[0];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto matrix = GetPointer(value.As<v8::Object>());
+            canvas_native_matrix_multiply_self(ptr->GetMatrix(), matrix->GetMatrix());
+        }
+    }
+}
+
+void MatrixImpl::PremultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto value = args[0];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto matrix = GetPointer(value.As<v8::Object>());
+            canvas_native_matrix_premultiply_self(ptr->GetMatrix(), matrix->GetMatrix());
+        }
+    }
+}
+
+void MatrixImpl::ScaleNonUniform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 3) {
+        auto context = isolate->GetCurrentContext();
+        auto sx = args[0];
+        auto sy = args[1];
+        auto value = args[2];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_scale_non_uniform(
+                    (float) sx->NumberValue(context).ToChecked(),
+                    (float) sy->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(ret, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::ScaleNonUniformSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+        canvas_native_matrix_scale_non_uniform_self(ptr->GetMatrix(),
+                                                    (float) x->NumberValue(context).ToChecked(),
+                                                    (float) y->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::Rotate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 4) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto cx = args[1];
+        auto cy = args[2];
+        auto value = args[3];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_rotate(
+                    (float) angle->NumberValue(context).ToChecked(),
+                    (float) cx->NumberValue(context).ToChecked(),
+                    (float) cy->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(ret, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::RotateSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto cx = args[1];
+        auto cy = args[2];
+        canvas_native_matrix_rotate_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked(),
+                                         (float) cx->NumberValue(context).ToChecked(),
+                                         (float) cy->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::SkewX(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto value = args[1];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_skew_x(
+                    (float) angle->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(ret, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::SkewXSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        canvas_native_matrix_skew_x_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::SkewY(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto value = args[1];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_skew_y(
+                    angle->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(ret, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::SkewYSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        canvas_native_matrix_skew_y_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::Clone(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    auto matrix = canvas_native_matrix_clone(ptr->GetMatrix());
+
+
+    auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+            context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+    auto object = new MatrixImpl(matrix);
+
+    ret->SetAlignedPointerInInternalField(0, object);
+
+    SetNativeType(ret, NativeType::Matrix);
+
+    object->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+}
+
+
 Matrix *MatrixImpl::GetMatrix() {
     return this->matrix_;
 }
+
+

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

@@ -184,6 +184,33 @@ public:
                        v8::Local<v8::Value> value,
                        const v8::PropertyCallbackInfo<void> &info);
 
+
+    static void Translate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TranslateSelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void MultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PremultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ScaleNonUniform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ScaleNonUniformSelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Rotate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RotateSelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SkewX(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SkewXSelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SkewY(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SkewYSelf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Clone(const v8::FunctionCallbackInfo<v8::Value> &args);
+
 private:
     Matrix* matrix_;
 };

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

@@ -51,9 +51,6 @@ v8::CFunction Path2D::fast_quadratic_curve_to_(v8::CFunction::Make(Path2D::FastQ
 
 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));
 
@@ -65,6 +62,8 @@ const v8::CFunction fast_round_rect_overloads_[] = {
         Path2D::fast_round_rect_array_
 };
 
+v8::CFunction Path2D::fast_trim_(v8::CFunction::Make(Path2D::FastTrim));
+
 
 
 //v8::CFunction Path2D::fast_to_svg_(v8::CFunction::Make(Path2D::FastToSVG));
@@ -76,7 +75,7 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType( ret, NativeType::Path2D);
+    SetNativeType(ret, NativeType::Path2D);
 
     if (count > 0) {
         if (value->IsString()) {
@@ -385,6 +384,21 @@ void Path2D::RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args) {
     args.GetReturnValue().SetUndefined();
 }
 
+void Path2D::Trim(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_trim(ptr->GetPath(),
+                            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+                            static_cast<float>(args[1]->NumberValue(context).ToChecked()));
+}
+
 void Path2D::__toSVG(const v8::FunctionCallbackInfo<v8::Value> &args) {
     Path2D *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
@@ -443,50 +457,7 @@ v8::Local<v8::FunctionTemplate> Path2D::GetCtor(v8::Isolate *isolate) {
     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));
+    SetFastMethod(isolate, tmpl, "trim", Trim, &fast_trim_, v8::Local<v8::Value>());
 
     tmpl->Set(
             ConvertToV8String(isolate, "__toSVG"),

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

@@ -64,6 +64,8 @@ public:
     static v8::CFunction fast_round_rect_array_;
     // static v8::CFunction fast_to_svg_; // todo after v8 upgrade
 
+    static v8::CFunction fast_trim_;
+
 
     static void Arc(const v8::FunctionCallbackInfo<v8::Value> &args);
 
@@ -429,6 +431,23 @@ public:
 
     static void RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void Trim(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastTrim(v8::Local<v8::Object> receiver_obj, double start, double end) {
+
+        Path2D *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_path_trim(
+                ptr->GetPath(),
+                static_cast<float>(start),
+                static_cast<float>(end)
+        );
+    }
+
     static void __toSVG(const v8::FunctionCallbackInfo<v8::Value> &args);