@nativescript/canvas 2.0.0-beta.0 → 2.0.0-beta.10

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -15,8 +15,8 @@ ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
-     canvas_native_image_asset_destroy(this->GetImageAsset());
-     asset_ = nullptr;
+    canvas_native_image_asset_destroy(this->GetImageAsset());
+    asset_ = nullptr;
 }
 
 void ImageAssetImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
@@ -62,6 +62,10 @@ v8::Local<v8::FunctionTemplate> ImageAssetImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "error"),
             GetError);
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
+
     tmpl->Set(
             ConvertToV8String(isolate, "scale"),
             v8::FunctionTemplate::New(isolate, &Scale));
@@ -112,7 +116,7 @@ void ImageAssetImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType( ret, NativeType::ImageAsset);
+    SetNativeType(ret, NativeType::ImageAsset);
 
     auto image_asset = canvas_native_image_asset_create();
 
@@ -149,6 +153,21 @@ ImageAssetImpl::GetHeight(v8::Local<v8::String> name,
     info.GetReturnValue().Set(0);
 }
 
+
+void
+ImageAssetImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto addr = static_cast<intptr_t *>(static_cast<void *>(ptr->GetImageAsset()));
+        auto ret = std::to_string(*addr);
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret.c_str()));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
 void
 ImageAssetImpl::GetError(v8::Local<v8::String> name,
                          const v8::PropertyCallbackInfo<v8::Value> &info) {

package/platforms/ios/src/cpp/ImageAssetImpl.h

@@ -16,13 +16,13 @@
 
 class ImageAssetImpl: ObjectWrapperImpl{
 public:
-    
+
     ImageAssetImpl(ImageAsset* asset);
 
     ~ImageAssetImpl();
 
     ImageAsset* GetImageAsset();
-    
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static ImageAssetImpl *GetPointer(const v8::Local<v8::Object>& object);
@@ -37,6 +37,9 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetAddr(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void GetError(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 

package/platforms/ios/src/cpp/ObjectWrapperImpl.h

@@ -12,17 +12,19 @@
 
 class ObjectWrapperImpl {
 public:
-    void BindFinalizer(v8::Isolate *isolate, const v8::Local<v8::Object> &object) {
-        v8::HandleScope scopedHandle(isolate);
-        weakHandle_.Reset(isolate, object);
-        weakHandle_.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
-    }
-    
+
     static void Finalizer(const v8::WeakCallbackInfo<ObjectWrapperImpl> &data) {
         auto *pThis = data.GetParameter();
         pThis->weakHandle_.Reset();
         delete pThis;
     }
+
+    void BindFinalizer(v8::Isolate *isolate, const v8::Local<v8::Object> &object) {
+        v8::HandleScope scopedHandle(isolate);
+        weakHandle_.Reset(isolate, object);
+        weakHandle_.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
+    }
+
 private:
     v8::Global<v8::Object> weakHandle_;
 

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

@@ -6,10 +6,19 @@
 #include "Caches.h"
 #include "OneByteStringResource.h"
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_start_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStartRaf));
+
+v8::CFunction CanvasRenderingContext2DImpl::fast_stop_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStopRaf));
 
 v8::CFunction CanvasRenderingContext2DImpl::fast_draw_point_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastDrawPoint));
 
+//v8::CFunction CanvasRenderingContext2DImpl::fast_draw_atlas_(
+//        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastDrawAtlas));
+
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_ellipse_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastEllipse));
 
@@ -81,13 +90,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));
 
@@ -251,6 +266,27 @@ CanvasRenderingContext2DImpl::GetPointer(const v8::Local<v8::Object> &object) {
     return static_cast<CanvasRenderingContext2DImpl *>(ptr);
 }
 
+
+void CanvasRenderingContext2DImpl::StartRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+}
+
+
+void CanvasRenderingContext2DImpl::StopRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_stop(raf->GetRaf());
+        }
+    }
+}
+
+
 v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->CanvasRenderingContext2DTmpl.get();
@@ -264,6 +300,13 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+
+    SetFastMethod(isolate, tmpl, "__startRaf", __StartRaf, &fast_start_raf_,
+                  v8::Local<v8::Value>());
+
+    SetFastMethod(isolate, tmpl, "__stopRaf", __StopRaf, &fast_stop_raf_,
+                  v8::Local<v8::Value>());
+
     SetFastMethod(isolate, tmpl, "drawPoint", DrawPoint, &fast_draw_point_, v8::Local<v8::Value>());
 
     tmpl->Set(ConvertToV8String(isolate, "drawPoints"),
@@ -278,6 +321,9 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
               v8::FunctionTemplate::New(isolate, __GetPointer));
     tmpl->Set(ConvertToV8String(isolate, "__resize"), v8::FunctionTemplate::New(isolate, __Resize));
 
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
     tmpl->SetAccessor(ConvertToV8String(isolate, "filter"), GetFilter, SetFilter);
     tmpl->SetAccessor(ConvertToV8String(isolate, "font"), GetFont, SetFont);
     tmpl->SetAccessor(ConvertToV8String(isolate, "letterSpacing"), GetLetterSpacing,
@@ -319,24 +365,19 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
 
     SetFastMethod(isolate, tmpl, "beginPath", BeginPath, &fast_begin_path_, v8::Local<v8::Value>());
 
-
     SetFastMethod(isolate, tmpl, "bezierCurveTo", BezierCurveTo, &fast_bezier_curve_to_,
                   v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "clearHitRegions"),
               v8::FunctionTemplate::New(isolate, &ClearHitRegions));
 
-
     SetFastMethod(isolate, tmpl, "clearRect", ClearRect, &fast_clear_rect_, v8::Local<v8::Value>());
 
-
     SetFastMethodWithOverLoads(isolate, tmpl, "clip", Clip, fast_clip_overloads_,
                                v8::Local<v8::Value>());
 
     SetFastMethod(isolate, tmpl, "closePath", ClosePath, &fast_close_path_, v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "createImageData"),
               v8::FunctionTemplate::New(isolate, &CreateImageData));
     tmpl->Set(ConvertToV8String(isolate, "createPattern"),
@@ -352,6 +393,11 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     tmpl->Set(ConvertToV8String(isolate, "drawFocusIfNeeded"),
               v8::FunctionTemplate::New(isolate, &DrawFocusIfNeeded));
 
+    tmpl->Set(ConvertToV8String(isolate, "drawAtlas"),
+              v8::FunctionTemplate::New(isolate, &DrawAtlas));
+
+
+//    SetFastMethod(isolate, tmpl, "drawAtlas", DrawAtlas, &fast_draw_atlas_, v8::Local<v8::Value>());
 
     SetFastMethodWithOverLoads(isolate, tmpl, "drawImage", DrawImage, fast_draw_overloads_,
                                v8::Local<v8::Value>());
@@ -365,6 +411,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"),
@@ -429,6 +479,10 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
                                fast_set_transform_overloads_, v8::Local<v8::Value>());
 
 
+    tmpl->Set(ConvertToV8String(isolate, "getTransform"),
+              v8::FunctionTemplate::New(isolate, &GetTransform));
+
+
     SetFastMethodWithOverLoads(isolate, tmpl, "stroke", Stroke, fast_stroke_overloads_,
                                v8::Local<v8::Value>());
 
@@ -440,6 +494,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>());
 
 
@@ -462,6 +520,59 @@ RafImpl *CanvasRenderingContext2DImpl::GetRaf() {
     return this->raf_.get();
 }
 
+
+void CanvasRenderingContext2DImpl::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StartRaf();
+
+}
+
+void CanvasRenderingContext2DImpl::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StopRaf();
+
+}
+
+
+void CanvasRenderingContext2DImpl::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void CanvasRenderingContext2DImpl::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto val = value->BooleanValue(isolate);
+    if (val == ptr->continuousRender_) {
+        return;
+    }
+    if (val) {
+        ptr->StartRaf();
+    } else {
+        ptr->StopRaf();
+    }
+    ptr->continuousRender_ = val;
+}
+
+
 /* Non Standard 2D */
 
 void CanvasRenderingContext2DImpl::DrawPoint(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -491,26 +602,16 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
     auto context = isolate->GetCurrentContext();
 
 
-    auto mode = ConvertFromV8String(isolate, args[0]);
+    auto mode = args[0];
     auto points = args[1].As<v8::Array>();
     auto size = points->Length();
 
-
-    if ((size % 2) == 0) {
-        int32_t pointMode = -1;
-        if (mode == "points") {
-            pointMode = 0;
-        } else if (mode == "lines") {
-            pointMode = 1;
-        } else if (mode == "polygon") {
-            pointMode = 2;
-        }
-        if (pointMode == -1) {
-            return;
-        }
+    if (size == 0) { return; }
+    uint32_t pointMode = 0;
+    if (mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)) {
         std::vector<float> store;
-        store.reserve(size);
-        int next = 0;
+        auto len = size * 2;
+        store.reserve(len);
         for (int i = 0; i < size; i++) {
 
             auto object = points->Get(
@@ -522,10 +623,8 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
             auto y = object->Get(context,
                                  ConvertToV8String(isolate, "y")).ToLocalChecked()->NumberValue(
                     context).ToChecked();
-            store[next] = (float) x;
-            store[next + 1] = (float) y;
-
-            next = i + 2;
+            store.emplace_back((float) x);
+            store.emplace_back((float) y);
         }
 
         canvas_native_context_draw_points(
@@ -1787,6 +1886,143 @@ CanvasRenderingContext2DImpl::DrawFocusIfNeeded(const v8::FunctionCallbackInfo<v
 }
 
 
+void
+CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value> &args) {
+
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto count = args.Length();
+    auto value = args[0];
+
+    if (value->IsNullOrUndefined() || !value->IsObject()) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto image = value.As<v8::Object>();
+    auto imageType = GetNativeType(image);
+
+
+    auto xformValue = args[1];
+    auto texValue = args[2];
+    auto colorsValue = args[3];
+    auto blendValue = args[4];
+
+    if (xformValue->IsArray() && texValue->IsArray()) {
+
+        std::vector<float> xform;
+        std::vector<float> tex;
+
+        v8::Local<v8::Array> xformArray = xformValue.As<v8::Array>();
+        v8::Local<v8::Array> texArray = texValue.As<v8::Array>();
+
+        auto xformLen = xformArray->Length();
+        xform.reserve(xformLen);
+        auto texLen = texArray->Length();
+        tex.reserve(texLen);
+
+
+        for (int i = 0; i < xformLen; i++) {
+            xform.emplace_back((float) xformArray->Get(context, i).ToLocalChecked()->NumberValue(
+                    context).ToChecked());
+        }
+
+        for (int i = 0; i < texLen; i++) {
+            tex.emplace_back((float) texArray->Get(context, i).ToLocalChecked()->NumberValue(
+                    context).ToChecked());
+        }
+
+        std::vector<std::string> colors;
+        std::vector<const char *> colors_ref;
+
+        // dst-over
+        int32_t mode = 4;
+
+        if (blendValue->IsInt32()) {
+            blendValue->Int32Value(context).To(&mode);
+        }
+
+        if (colorsValue->IsArray()) {
+            auto colorsArray = colorsValue.As<v8::Array>();
+            auto colorsLen = colorsArray->Length();
+            colors.reserve(colorsLen);
+            colors_ref.reserve(colorsLen);
+            for (int i = 0; i < colorsLen; i++) {
+                auto str = ConvertFromV8String(isolate, texArray->Get(context, i).ToLocalChecked());
+                colors.emplace_back(str);
+                colors_ref.emplace_back(str.c_str());
+            }
+        }
+
+        switch (imageType) {
+            case NativeType::ImageAsset: {
+                auto image_asset = ImageAssetImpl::GetPointer(image);
+
+                if (image_asset != nullptr) {
+
+                    if (colors.empty()) {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_asset->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), nullptr,
+                                                               0, mode);
+                    } else {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_asset->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), colors_ref.data(),
+                                                               colors_ref.size(), mode);
+                    }
+
+
+                    ptr->UpdateInvalidateState();
+                }
+            }
+                break;
+            case NativeType::ImageBitmap: {
+                auto image_bitmap = ImageBitmapImpl::GetPointer(image);
+                if (image_bitmap != nullptr) {
+                    if (colors.empty()) {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_bitmap->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), nullptr,
+                                                               0, mode);
+                    } else {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_bitmap->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), colors_ref.data(),
+                                                               colors_ref.size(), mode);
+                    }
+                }
+            }
+                break;
+            case NativeType::CanvasRenderingContext2D: {
+                auto image_canvas = CanvasRenderingContext2DImpl::GetPointer(image);
+                if (image_canvas != nullptr) {
+
+                    ptr->UpdateInvalidateState();
+                }
+            }
+                break;
+            default:
+                break;
+        }
+    }
+
+
+}
+
+
 void
 CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
@@ -2007,33 +2243,19 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
 
             if (object != nullptr) {
                 auto rule = args[1]->Uint32Value(context).ToChecked();
-                switch (rule) {
-                    case 0:
-                    case 1:
-                        canvas_native_context_fill_with_path(
-                                ptr->GetContext(),
-                                object->GetPath(), rule);
-                        ptr->UpdateInvalidateState();
-                        break;
-                    default:
-                        break;
-                }
-
+                canvas_native_context_fill_with_path(
+                        ptr->GetContext(),
+                        object->GetPath(), rule);
+                ptr->UpdateInvalidateState();
             }
         }
     } else if (count == 1) {
-        if (value->IsInt32()) {
-            auto rule = args[1]->Uint32Value(context).ToChecked();
-            switch (rule) {
-                case 0:
-                    canvas_native_context_fill(
-                            ptr->GetContext(),
-                            rule);
-                    ptr->UpdateInvalidateState();
-                    break;
-                default:
-                    break;
-            }
+        if (value->IsUint32()) {
+            auto rule = value->Uint32Value(context).ToChecked();
+            canvas_native_context_fill(
+                    ptr->GetContext(),
+                    rule);
+            ptr->UpdateInvalidateState();
         } else if (value->IsObject()) {
             auto type = GetNativeType(value.As<v8::Object>());
             if (type == NativeType::Path2D) {
@@ -2100,6 +2322,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());
@@ -2186,16 +2428,8 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
         auto x = static_cast<float>(args[0]->NumberValue(context).ToChecked());
         auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
         auto rule = args[2]->Uint32Value(context).ToChecked();
-        bool ret = false;
-        switch (rule) {
-            case 0:
-            case 1:
-                ret = canvas_native_context_is_point_in_path(
-                        ptr->GetContext(), x, y, rule);
-                break;
-            default:
-                break;
-        }
+        bool ret = canvas_native_context_is_point_in_path(
+                ptr->GetContext(), x, y, rule);
         args.GetReturnValue().Set(ret);
         return;
     } else if (count == 4 &&
@@ -2210,20 +2444,12 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
             auto x = static_cast<float>(args[1]->NumberValue(context).ToChecked());
             auto y = static_cast<float>(args[2]->NumberValue(context).ToChecked());
             auto rule = args[3]->Uint32Value(context).ToChecked();
-            bool ret = false;
 
             if (path != nullptr) {
 
-                switch (rule) {
-                    case 0:
-                    case 1:
-                        ret = canvas_native_context_is_point_in_path_with_path(
-                                ptr->GetContext(),
-                                path->GetPath(), x, y, rule);
-                        break;
-                    default:
-                        break;
-                }
+                bool ret = canvas_native_context_is_point_in_path_with_path(
+                        ptr->GetContext(),
+                        path->GetPath(), x, y, rule);
 
                 args.GetReturnValue().Set(ret);
                 return;
@@ -2607,6 +2833,30 @@ CanvasRenderingContext2DImpl::SetTransform(const v8::FunctionCallbackInfo<v8::Va
     }
 }
 
+
+void
+CanvasRenderingContext2DImpl::GetTransform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto matrix = canvas_native_context_get_transform(ptr->GetContext());
+
+
+    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);
+}
+
 void
 CanvasRenderingContext2DImpl::Stroke(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
@@ -2678,6 +2928,27 @@ 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());
@@ -2787,11 +3058,7 @@ void CanvasRenderingContext2DImpl::Flush() {
     auto state = (int) this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState(InvalidateState::InvalidateStateInvalidating);
-        //   canvas_native_context_flush(ptr->GetContext());
-
         canvas_native_context_render(this->GetContext());
-        //        canvas_native_context_gl_make_current(ptr->GetContext());
-        //        canvas_native_context_gl_swap_buffers(ptr->GetContext());
         this->SetInvalidateState(InvalidateState::InvalidateStateNone);
     }
 }