@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

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

@@ -11,14 +11,14 @@
 class TextEncoderImpl: ObjectWrapperImpl {
 
 public:
-    TextEncoderImpl(TextEncoder* encoder);
+    explicit TextEncoderImpl(TextEncoder* encoder);
     ~TextEncoderImpl() {
-        canvas_native_text_encoder_destroy(this->GetTextEncoder());
+        canvas_native_text_encoder_release(this->GetTextEncoder());
         this->encoder_ = nullptr;
     }
 
     TextEncoder* GetTextEncoder();
-    
+
     static void Init(const v8::Local<v8::Object>& canvasModule, v8::Isolate *isolate);
 
     static TextEncoderImpl *GetPointer(v8::Local<v8::Object> object);

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

@@ -3,21 +3,22 @@
 //
 
 #pragma once
+
 #include <vector>
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class CanvasGradient: ObjectWrapperImpl {
+class CanvasGradient : ObjectWrapperImpl {
 public:
-    CanvasGradient(PaintStyle*style);
+    explicit CanvasGradient(PaintStyle *style);
 
-    ~CanvasGradient(){
-        canvas_native_paint_style_destroy(this->GetPaintStyle());
+    ~CanvasGradient() {
+        canvas_native_paint_style_release(this->GetPaintStyle());
         this->style_ = nullptr;
     }
 
-    PaintStyle * GetPaintStyle();
+    PaintStyle *GetPaintStyle();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -30,7 +31,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasGradient::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::CanvasGradient);
+        SetNativeType(gradient, NativeType::CanvasGradient);
         object->SetAlignedPointerInInternalField(0, gradient);
         gradient->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -39,6 +40,6 @@ public:
     static void AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    PaintStyle* style_;
+    PaintStyle *style_;
 };
 

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

@@ -17,7 +17,7 @@ void CanvasPattern::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func).FromJust();
 }
 
 v8::CFunction CanvasPattern::fast_set_transform_(
@@ -31,16 +31,6 @@ CanvasPattern *CanvasPattern::GetPointer(const v8::Local<v8::Object> &object) {
     return static_cast<CanvasPattern *>(ptr);
 }
 
-static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasPattern *pattern) {
-    auto context = isolate->GetCurrentContext();
-    v8::EscapableHandleScope scope(isolate);
-    auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
-            context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-    SetNativeType(object, NativeType::CanvasPattern);
-    object->SetAlignedPointerInInternalField(0, pattern);
-    return scope.Escape(object);
-}
-
 v8::Local<v8::FunctionTemplate> CanvasPattern::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->CanvasPatternTmpl.get();

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

@@ -10,10 +10,10 @@
 
 class CanvasPattern : ObjectWrapperImpl {
 public:
-    CanvasPattern(PaintStyle *style);
+    explicit CanvasPattern(PaintStyle *style);
 
     ~CanvasPattern() {
-        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        canvas_native_paint_style_release(this->GetPaintStyle());
         this->style_ = nullptr;
     }
 
@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::CanvasPattern);
+        SetNativeType(pattern, NativeType::CanvasPattern);
         object->SetAlignedPointerInInternalField(0, pattern);
         pattern->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -5,6 +5,7 @@
 #include "CanvasRenderingContext2DImpl.h"
 #include "Caches.h"
 #include "OneByteStringResource.h"
+#include "WebGLRenderingContextBase.h"
 
 v8::CFunction CanvasRenderingContext2DImpl::fast_start_raf_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStartRaf));
@@ -254,7 +255,8 @@ void CanvasRenderingContext2DImpl::Init(v8::Local<v8::Object> canvasModule, v8::
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"),
+                      func).FromJust();
 }
 
 CanvasRenderingContext2DImpl *
@@ -628,7 +630,7 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
         }
 
         canvas_native_context_draw_points(
-                ptr->GetContext(), pointMode,
+                ptr->GetContext(), (int32_t)pointMode,
                 store.data(), store.size());
 
 
@@ -1108,7 +1110,6 @@ void CanvasRenderingContext2DImpl::SetTextAlign(v8::Local<v8::String> property,
 void CanvasRenderingContext2DImpl::GetTextBaseline(v8::Local<v8::String> property,
                                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
-    auto isolate = info.GetIsolate();
     if (ptr == nullptr) {
         info.GetReturnValue().Set(0);
         return;
@@ -1205,10 +1206,6 @@ void CanvasRenderingContext2DImpl::GetFillStyle(v8::Local<v8::String> property,
             info.GetReturnValue().Set(style);
             break;
         }
-        case PaintStyleType::PaintStyleTypeNone: {
-            info.GetReturnValue().SetUndefined();
-            break;
-        }
     }
 
 }
@@ -1288,10 +1285,6 @@ void CanvasRenderingContext2DImpl::GetStrokeStyle(v8::Local<v8::String> property
             info.GetReturnValue().Set(style);
             break;
         }
-        case PaintStyleType::PaintStyleTypeNone: {
-            info.GetReturnValue().SetUndefined();
-            break;
-        }
     }
 
 }
@@ -1380,7 +1373,7 @@ void CanvasRenderingContext2DImpl::GetLineDash(v8::Local<v8::String> property,
     auto ret = v8::Array::New(isolate, (int) size);
     for (int i = 0; i < size; i++) {
         auto item = buf[i];
-        ret->Set(context, i, v8::Number::New(isolate, (double) item));
+        ret->Set(context, i, v8::Number::New(isolate, (double) item)).FromJust();
     }
 
 }
@@ -1539,13 +1532,13 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
     auto count = args.Length();
     if (count == 0) {
         canvas_native_context_clip_rule(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
     } else if (count == 1 && args[0]->IsUint32()) {
         uint32_t val = 0;
 
         if (args[0]->Uint32Value(context).To(&val)) {
             canvas_native_context_clip_rule(
-                    ptr->GetContext(), val);
+                    ptr->GetContext(), val == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
         }
     } else if (count == 1 && args[0]->IsObject()) {
         auto type = GetNativeType(args[0].As<v8::Object>());
@@ -1554,7 +1547,7 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
 
             if (object != nullptr) {
                 canvas_native_context_clip(
-                        ptr->GetContext(), object->GetPath(), 0);
+                        ptr->GetContext(), object->GetPath(), CanvasFillRuleNonZero);
             }
         }
     } else if (count >= 2 && args[0]->IsObject() && args[1]->IsUint32()) {
@@ -1565,7 +1558,8 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
 
             if (args[1]->Uint32Value(context).To(&rule)) {
                 canvas_native_context_clip(
-                        ptr->GetContext(), object->GetPath(), rule);
+                        ptr->GetContext(), object->GetPath(),
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
             }
         }
     }
@@ -1614,7 +1608,7 @@ CanvasRenderingContext2DImpl::CreateImageData(const v8::FunctionCallbackInfo<v8:
 
             ret->SetAlignedPointerInInternalField(0, data);
 
-            SetNativeType(ret, NativeType::ImageData);
+            SetNativeType(data, NativeType::ImageData);
 
             args.GetReturnValue().Set(ret);
 
@@ -1634,7 +1628,7 @@ CanvasRenderingContext2DImpl::CreateImageData(const v8::FunctionCallbackInfo<v8:
 
         ret->SetAlignedPointerInInternalField(0, data);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(data, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
     }
@@ -1660,18 +1654,36 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto image_asset = ImageAssetImpl::GetPointer(value.As<v8::Object>());
                 if (image_asset != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_asset(
-                            ptr->GetContext(),
-                            image_asset->GetImageAsset(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+
+                    PaintStyle *style = nullptr;
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
                     }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
+                    }
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1679,18 +1691,37 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto image_bitmap = ImageBitmapImpl::GetPointer(value.As<v8::Object>());
                 if (image_bitmap != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_asset(
-                            ptr->GetContext(),
-                            image_bitmap->GetImageAsset(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
                     }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
+                    }
+
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1699,18 +1730,36 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                         value.As<v8::Object>());
                 if (canvas_2d != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_canvas2d(
-                            canvas_2d->GetContext(),
-                            ptr->GetContext(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
+                    }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
                     }
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1718,21 +1767,40 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto webgl = WebGLRenderingContextBase::GetPointer(value.As<v8::Object>());
                 if (webgl != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_webgl(
-                            webgl->GetState(),
-                            ptr->GetContext(), rep.c_str());
-                    auto type = canvas_native_context_get_style_type(pattern);
-                    if (type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetNull();
-                        canvas_native_paint_style_destroy(pattern);
-                        return;
+
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeatY);
                     } else {
-                        auto ret = CanvasPattern::NewInstance(isolate, new CanvasPattern(
-                                pattern));
-                        args.GetReturnValue().Set(ret);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
                         return;
                     }
+
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
+                    }
+
+                    auto ret = CanvasPattern::NewInstance(isolate, new CanvasPattern(
+                            style));
+                    args.GetReturnValue().Set(ret);
+                    return;
                 }
                 return;
             }
@@ -1830,16 +1898,16 @@ CanvasRenderingContext2DImpl::__CreatePatternWithNative(
     auto pointer = args[0]->ToBigInt(context).ToLocalChecked();
 
     auto pattern = canvas_native_pattern_from_ptr(pointer->Int64Value());
-    auto type = canvas_native_context_get_style_type(pattern);
-    if (type == PaintStyleType::PaintStyleTypeNone) {
-        args.GetReturnValue().SetUndefined();
-        canvas_native_paint_style_destroy(pattern);
-    } else {
-        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
 
-        args.GetReturnValue().Set(data);
+    if (pattern == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
     }
 
+    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
+
+    args.GetReturnValue().Set(data);
+
 }
 
 void
@@ -1894,7 +1962,6 @@ CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value
         return;
     }
 
-    auto count = args.Length();
     auto value = args[0];
 
     if (value->IsNullOrUndefined() || !value->IsObject()) {
@@ -1943,7 +2010,7 @@ CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value
         int32_t mode = 4;
 
         if (blendValue->IsInt32()) {
-            blendValue->Int32Value(context).To(&mode);
+            auto val = blendValue->Int32Value(context).To(&mode);
         }
 
         if (colorsValue->IsArray()) {
@@ -2081,6 +2148,17 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_dx_dy_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            dx, dy
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -2131,6 +2209,17 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_dx_dy_dw_dh_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            dx, dy, dWidth, dHeight
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -2189,6 +2278,20 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            sx,
+                            sy, sWidth, sHeight,
+                            dx,
+                            dy, dWidth, dHeight
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -2245,7 +2348,8 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
                 auto rule = args[1]->Uint32Value(context).ToChecked();
                 canvas_native_context_fill_with_path(
                         ptr->GetContext(),
-                        object->GetPath(), rule);
+                        object->GetPath(),
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
                 ptr->UpdateInvalidateState();
             }
         }
@@ -2254,7 +2358,7 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
             auto rule = value->Uint32Value(context).ToChecked();
             canvas_native_context_fill(
                     ptr->GetContext(),
-                    rule);
+                    rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
             ptr->UpdateInvalidateState();
         } else if (value->IsObject()) {
             auto type = GetNativeType(value.As<v8::Object>());
@@ -2263,13 +2367,13 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
 
                 canvas_native_context_fill_with_path(
                         ptr->GetContext(),
-                        object->GetPath(), 0);
+                        object->GetPath(), CanvasFillRuleNonZero);
                 ptr->UpdateInvalidateState();
             }
         }
     } else {
         canvas_native_context_fill(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 }
@@ -2369,7 +2473,7 @@ CanvasRenderingContext2DImpl::GetImageData(const v8::FunctionCallbackInfo<v8::Va
 
         ret->SetAlignedPointerInInternalField(0, data);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(data, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
         return;
@@ -2402,7 +2506,7 @@ CanvasRenderingContext2DImpl::GetLineDash(const v8::FunctionCallbackInfo<v8::Val
     for (int i = 0; i < size; ++i) {
         array->Set(context, i,
                    v8::Number::New(isolate,
-                                   (double) buf[i]));
+                                   (double) buf[i])).FromJust();
     }
 
     args.GetReturnValue().Set(array);
@@ -2420,7 +2524,7 @@ 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 ret = canvas_native_context_is_point_in_path(
-                ptr->GetContext(), x, y, 0);
+                ptr->GetContext(), x, y, CanvasFillRuleNonZero);
         args.GetReturnValue().Set(ret);
         return;
     } else if (count == 3 &&
@@ -2429,7 +2533,7 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
         auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
         auto rule = args[2]->Uint32Value(context).ToChecked();
         bool ret = canvas_native_context_is_point_in_path(
-                ptr->GetContext(), x, y, rule);
+                ptr->GetContext(), x, y, rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
         args.GetReturnValue().Set(ret);
         return;
     } else if (count == 4 &&
@@ -2449,7 +2553,8 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
 
                 bool ret = canvas_native_context_is_point_in_path_with_path(
                         ptr->GetContext(),
-                        path->GetPath(), x, y, rule);
+                        path->GetPath(), x, y,
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
 
                 args.GetReturnValue().Set(ret);
                 return;
@@ -2541,7 +2646,7 @@ CanvasRenderingContext2DImpl::MeasureText(const v8::FunctionCallbackInfo<v8::Val
 
     data->BindFinalizer(isolate, ret);
 
-    SetNativeType(ret, NativeType::TextMetrics);
+    SetNativeType(data, NativeType::TextMetrics);
 
     args.GetReturnValue().Set(ret);
 
@@ -2850,7 +2955,7 @@ CanvasRenderingContext2DImpl::GetTransform(const v8::FunctionCallbackInfo<v8::Va
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::Matrix);
+    SetNativeType(object, NativeType::Matrix);
 
     object->BindFinalizer(isolate, ret);
 
@@ -2861,8 +2966,6 @@ void
 CanvasRenderingContext2DImpl::Stroke(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::Path2D) {
@@ -3003,7 +3106,7 @@ CanvasRenderingContext2DImpl::__ToDataURL(const v8::FunctionCallbackInfo<v8::Val
 
 
     if (args[1]->IsNumber()) {
-        quality = (int) args[1]->NumberValue(context).ToChecked();
+        quality = (int) (args[1]->NumberValue(context).ToChecked() * 100);
     }
 
 
@@ -3024,17 +3127,17 @@ CanvasRenderingContext2DImpl::~CanvasRenderingContext2DImpl() {
         canvas_native_raf_stop(raf->GetRaf());
     }
 
-    canvas_native_context_destroy(this->GetContext());
+    canvas_native_context_release(this->GetContext());
     this->context_ = nullptr;
 }
 
 void CanvasRenderingContext2DImpl::UpdateInvalidateState() {
-    auto raf = this->GetRaf();
-    if (raf != nullptr) {
-        if (!canvas_native_raf_get_started(raf->GetRaf())) {
-            canvas_native_raf_start(raf->GetRaf());
-        }
-    }
+//    auto raf = this->GetRaf();
+//    if (raf != nullptr) {
+//        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+//            canvas_native_raf_start(raf->GetRaf());
+//        }
+//    }
 
     auto state = this->GetInvalidateState();
     this->SetInvalidateState((int) state | (int) InvalidateState::InvalidateStatePending);