@nativescript/canvas 2.0.0-beta.4 → 2.0.0-beta.6

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

@@ -86,13 +86,19 @@ v8::CFunction CanvasRenderingContext2DImpl::fast_clear_rect_(
 v8::CFunction CanvasRenderingContext2DImpl::fast_fill_rect_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFillRect));
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_fill_oval_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFillOval));
+
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_stroke_rect_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastStrokeRect));
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_stroke_oval_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastStrokeOval));
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_rotate_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastRotate));
 
-
 v8::CFunction CanvasRenderingContext2DImpl::fast_fill_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFill));
 
@@ -395,6 +401,10 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
 
     tmpl->Set(ConvertToV8String(isolate, "fillText"),
               v8::FunctionTemplate::New(isolate, &FillText));
+
+
+    SetFastMethod(isolate, tmpl, "fillOval", FillOval, &fast_fill_oval_, v8::Local<v8::Value>());
+
     tmpl->Set(ConvertToV8String(isolate, "getImageData"),
               v8::FunctionTemplate::New(isolate, &GetImageData));
     tmpl->Set(ConvertToV8String(isolate, "getLineDash"),
@@ -474,6 +484,10 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     tmpl->Set(ConvertToV8String(isolate, "strokeText"),
               v8::FunctionTemplate::New(isolate, &StrokeText));
 
+
+    SetFastMethod(isolate, tmpl, "strokeOval", StrokeOval, &fast_stroke_oval_,
+                  v8::Local<v8::Value>());
+
     SetFastMethod(isolate, tmpl, "transform", Transform, &fast_transform_, v8::Local<v8::Value>());
 
 
@@ -573,15 +587,15 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
-    
+
+
     auto mode = args[0];
     auto points = args[1].As<v8::Array>();
     auto size = points->Length();
-    
+
     if (size == 0){return;}
     uint32_t pointMode = 0;
     if(mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)){
@@ -589,10 +603,10 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
         auto len = size * 2;
         store.reserve(len);
         for (int i = 0; i < size; i++) {
-            
+
             auto object = points->Get(
                                       context, i).ToLocalChecked().As<v8::Object>();
-            
+
             auto x = object->Get(context,
                                  ConvertToV8String(isolate, "x")).ToLocalChecked()->NumberValue(
                                                                                                 context).ToChecked();
@@ -602,12 +616,12 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
             store.emplace_back((float) x);
             store.emplace_back((float) y);
         }
-        
+
         canvas_native_context_draw_points(
                                           ptr->GetContext(), pointMode,
                                           store.data(), store.size());
-        
-        
+
+
         ptr->UpdateInvalidateState();
     }
 }
@@ -2161,6 +2175,26 @@ CanvasRenderingContext2DImpl::FillText(const v8::FunctionCallbackInfo<v8::Value>
 
 }
 
+
+void
+CanvasRenderingContext2DImpl::FillOval(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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());
+    canvas_native_context_fill_oval(
+            ptr->GetContext(), x, y, width,
+            height);
+    ptr->UpdateInvalidateState();
+}
+
 void
 CanvasRenderingContext2DImpl::GetImageData(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
@@ -2747,6 +2781,29 @@ CanvasRenderingContext2DImpl::StrokeText(const v8::FunctionCallbackInfo<v8::Valu
     }
 }
 
+void
+CanvasRenderingContext2DImpl::StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() == 4) {
+        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());
+        canvas_native_context_stroke_oval(
+                ptr->GetContext(), x, y,
+                width,
+                height);
+        ptr->UpdateInvalidateState();
+    }
+}
+
+
+
+
 void
 CanvasRenderingContext2DImpl::Transform(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());

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

@@ -106,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_;
@@ -900,6 +904,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);
@@ -1325,6 +1350,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

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);