From 5d0ad5b7e972ca4a6db624da8dd48aae804484d8 Mon Sep 17 00:00:00 2001 From: ReneHollander Date: Thu, 15 Sep 2016 18:07:29 +0200 Subject: [PATCH 1/2] Updated to nan 2.4.0 --- openvg.js | 2 +- package.json | 14 +- src/argchecks.h | 184 ++--- src/egl.cc | 59 +- src/openvg.cc | 1784 ++++++++++++++++++++++------------------------- 5 files changed, 961 insertions(+), 1082 deletions(-) diff --git a/openvg.js b/openvg.js index bdd9be8..d648ea0 100755 --- a/openvg.js +++ b/openvg.js @@ -1,4 +1,4 @@ -var openVG = module.exports = require('./build/Release/openvg.node'); +var openVG = module.exports = require('bindings')('openvg.node'); var screen = openVG.screen = { width : null, diff --git a/package.json b/package.json index dc3b8de..d344e00 100644 --- a/package.json +++ b/package.json @@ -1,8 +1,11 @@ { "name": "openvg", "preferGlobal": "true", - "version": "0.4.6", + "version": "0.5.0", "author": "Luis Reis (http://luismreis.com/)", + "contributors": [ + "Rene Hollander (http://www.rene8888.at/)" + ], "description": "OpenVG bindings for node", "main": "openvg.js", "repository": { @@ -14,11 +17,8 @@ "openvg" ], "dependencies": { - "nan": "^1.8.4" + "nan": "^2.4.0", + "bindings": "^1.2.1" }, - "devDependencies": {}, - "license": "MIT", - "engines": { - "node": ">=0.8 <0.11" - } + "license": "MIT" } diff --git a/src/argchecks.h b/src/argchecks.h index 25d5995..f894452 100644 --- a/src/argchecks.h +++ b/src/argchecks.h @@ -6,173 +6,173 @@ #if defined(ARG_CHECKS) #define BASE_MESSAGE "Invalid arguments: Expected " -#define THROW(fn, args) NanThrowTypeError(BASE_MESSAGE #fn "(" args ")") +#define THROW(fn, info) NanThrowTypeError(BASE_MESSAGE #fn "(" info ")") #define CheckArgs0(fn) \ do {\ - if (!(args.Length() == 0)) {\ + if (!(info.Length() == 0)) {\ THROW(fn, );\ }\ } while(0) #define CheckArgs1(fn, arg0, type0) \ do {\ - if (!(args.Length() == 1 &&\ - args[0]->Is ## type0())) {\ + if (!(info.Length() == 1 &&\ + info[0]->Is ## type0())) {\ THROW(fn, #arg0);\ }\ } while(0) #define CheckArgs2(fn, arg0, type0, arg1, type1) \ do {\ - if (!(args.Length() == 2 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1())) {\ + if (!(info.Length() == 2 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1())) {\ THROW(fn, #arg0 "," #arg1);\ }\ } while(0) #define CheckArgs3(fn, arg0, type0, arg1, type1, arg2, type2) \ do {\ - if (!(args.Length() == 3 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2())) {\ + if (!(info.Length() == 3 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2);\ }\ } while(0) #define CheckArgs4(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3) \ do {\ - if (!(args.Length() == 4 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3())) {\ + if (!(info.Length() == 4 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3);\ }\ } while(0) #define CheckArgs5(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4) \ do {\ - if (!(args.Length() == 5 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4())) {\ + if (!(info.Length() == 5 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4);\ }\ } while(0) #define CheckArgs6(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5) \ do {\ - if (!(args.Length() == 6 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5())) {\ + if (!(info.Length() == 6 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5);\ }\ } while(0) #define CheckArgs7(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6) \ do {\ - if (!(args.Length() == 7 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6())) {\ + if (!(info.Length() == 7 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6);\ }\ } while(0) #define CheckArgs8(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6, arg7, type7) \ do {\ - if (!(args.Length() == 8 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6() &&\ - args[7]->Is ## type7())) {\ + if (!(info.Length() == 8 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6() &&\ + info[7]->Is ## type7())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6 "," #arg7);\ }\ } while(0) #define CheckArgs9(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6, arg7, type7, arg8, type8) \ do {\ - if (!(args.Length() == 9 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6() &&\ - args[7]->Is ## type7() &&\ - args[8]->Is ## type8())) {\ + if (!(info.Length() == 9 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6() &&\ + info[7]->Is ## type7() &&\ + info[8]->Is ## type8())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6 "," #arg7 "," #arg8);\ }\ } while(0) #define CheckArgs10(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6, arg7, type7, arg8, type8, arg9, type9) \ do {\ - if (!(args.Length() == 10 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6() &&\ - args[7]->Is ## type7() &&\ - args[8]->Is ## type8() &&\ - args[9]->Is ## type9())) {\ + if (!(info.Length() == 10 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6() &&\ + info[7]->Is ## type7() &&\ + info[8]->Is ## type8() &&\ + info[9]->Is ## type9())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6 "," #arg7 "," #arg8 "," #arg9);\ }\ } while(0) #define CheckArgs11(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6, arg7, type7, arg8, type8, arg9, type9, arg10, type10) \ do {\ - if (!(args.Length() == 11 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6() &&\ - args[7]->Is ## type7() &&\ - args[8]->Is ## type8() &&\ - args[9]->Is ## type9() &&\ - args[10]->Is ## type10())) {\ + if (!(info.Length() == 11 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6() &&\ + info[7]->Is ## type7() &&\ + info[8]->Is ## type8() &&\ + info[9]->Is ## type9() &&\ + info[10]->Is ## type10())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6 "," #arg7 "," #arg8 "," #arg9 "," #arg10);\ }\ } while(0) #define CheckArgs12(fn, arg0, type0, arg1, type1, arg2, type2, arg3, type3, arg4, type4, arg5, type5, arg6, type6, arg7, type7, arg8, type8, arg9, type9, arg10, type10, arg11, type11) \ do {\ - if (!(args.Length() == 12 &&\ - args[0]->Is ## type0() &&\ - args[1]->Is ## type1() &&\ - args[2]->Is ## type2() &&\ - args[3]->Is ## type3() &&\ - args[4]->Is ## type4() &&\ - args[5]->Is ## type5() &&\ - args[6]->Is ## type6() &&\ - args[7]->Is ## type7() &&\ - args[8]->Is ## type8() &&\ - args[9]->Is ## type9() &&\ - args[10]->Is ## type10() &&\ - args[11]->Is ## type11())) {\ + if (!(info.Length() == 12 &&\ + info[0]->Is ## type0() &&\ + info[1]->Is ## type1() &&\ + info[2]->Is ## type2() &&\ + info[3]->Is ## type3() &&\ + info[4]->Is ## type4() &&\ + info[5]->Is ## type5() &&\ + info[6]->Is ## type6() &&\ + info[7]->Is ## type7() &&\ + info[8]->Is ## type8() &&\ + info[9]->Is ## type9() &&\ + info[10]->Is ## type10() &&\ + info[11]->Is ## type11())) {\ THROW(fn, #arg0 "," #arg1 "," #arg2 "," #arg3 "," #arg4 "," #arg5 "," #arg6 "," #arg7 "," #arg8 "," #arg9 "," #arg10 "," #arg11);\ }\ } while(0) diff --git a/src/egl.cc b/src/egl.cc index 68ab896..54fdb3f 100755 --- a/src/egl.cc +++ b/src/egl.cc @@ -9,21 +9,20 @@ #include "argchecks.h" using namespace v8; -using namespace node; egl::state_t egl::State; EGLConfig egl::Config; extern void egl::InitBindings(Handle target) { - NODE_SET_METHOD(target, "getError" , egl::GetError); - NODE_SET_METHOD(target, "swapBuffers" , egl::SwapBuffers); - NODE_SET_METHOD(target, "createPbufferFromClientBuffer", + Nan::SetMethod(target, "getError" , egl::GetError); + Nan::SetMethod(target, "swapBuffers" , egl::SwapBuffers); + Nan::SetMethod(target, "createPbufferFromClientBuffer", egl::CreatePbufferFromClientBuffer); - NODE_SET_METHOD(target, "destroySurface", egl::DestroySurface); + Nan::SetMethod(target, "destroySurface", egl::DestroySurface); - NODE_SET_METHOD(target, "createContext" , egl::CreateContext); - NODE_SET_METHOD(target, "destroyContext", egl::DestroyContext); - NODE_SET_METHOD(target, "makeCurrent" , egl::MakeCurrent); + Nan::SetMethod(target, "createContext" , egl::CreateContext); + Nan::SetMethod(target, "destroyContext", egl::DestroyContext); + Nan::SetMethod(target, "makeCurrent" , egl::MakeCurrent); } extern void egl::Init() { @@ -144,28 +143,28 @@ extern void egl::Finish() { NAN_METHOD(egl::GetError) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(getError); - NanReturnValue(NanNew(eglGetError())); + info.GetReturnValue().Set(Nan::New(eglGetError())); } NAN_METHOD(egl::SwapBuffers) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(swapBuffers, surface, External); - EGLSurface surface = (EGLSurface) External::Cast(*args[0])->Value(); + EGLSurface surface = (EGLSurface) External::Cast(*info[0])->Value(); EGLBoolean result = eglSwapBuffers(State.display, surface); - NanReturnValue(NanNew(result)); + info.GetReturnValue().Set(Nan::New(result)); } NAN_METHOD(egl::CreatePbufferFromClientBuffer) { - NanScope(); + Nan::HandleScope scope; // According to the spec (sec. 4.2.2 EGL Functions) // The buffer is a VGImage: "The VGImage to be targeted is cast to the @@ -176,7 +175,7 @@ NAN_METHOD(egl::CreatePbufferFromClientBuffer) { CheckArgs1(CreatePbufferFromClientBuffer, vgImage, Number); EGLClientBuffer buffer = - reinterpret_cast(args[0]->Uint32Value()); + reinterpret_cast(info[0]->Uint32Value()); static const EGLint attribute_list[] = { EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, @@ -192,61 +191,61 @@ NAN_METHOD(egl::CreatePbufferFromClientBuffer) { egl::Config, attribute_list); - NanReturnValue(NanNew(surface)); + info.GetReturnValue().Set(Nan::New(surface)); } NAN_METHOD(egl::DestroySurface) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroySurface, surface, External); - EGLSurface surface = (EGLSurface) External::Cast(*args[0])->Value(); + EGLSurface surface = (EGLSurface) External::Cast(*info[0])->Value(); EGLBoolean result = eglDestroySurface(State.display, surface); - NanReturnValue(NanNew(result)); + info.GetReturnValue().Set(Nan::New(result)); } NAN_METHOD(egl::MakeCurrent) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(makeCurrent, surface, External, context, External); - EGLSurface surface = (EGLSurface) External::Cast(*args[0])->Value(); - EGLContext context = (EGLContext) External::Cast(*args[1])->Value(); + EGLSurface surface = (EGLSurface) External::Cast(*info[0])->Value(); + EGLContext context = (EGLContext) External::Cast(*info[1])->Value(); // According to EGL 1.4 spec, 3.7.3, for OpenVG contexts, draw and read // surfaces must be the same EGLBoolean result = eglMakeCurrent(State.display, surface, surface, context); - NanReturnValue(NanNew(result)); + info.GetReturnValue().Set(Nan::New(result)); } NAN_METHOD(egl::CreateContext) { - NanScope(); + Nan::HandleScope scope; // No arg checks - EGLContext shareContext = args.Length() == 0 ? + EGLContext shareContext = info.Length() == 0 ? EGL_NO_CONTEXT : - (EGLContext) External::Cast(*args[0])->Value(); + (EGLContext) External::Cast(*info[0])->Value(); // According to EGL 1.4 spec, 3.7.3, for OpenVG contexts, draw and read // surfaces must be the same EGLContext result = eglCreateContext(State.display, egl::Config, shareContext, NULL); - NanReturnValue(NanNew(result)); + info.GetReturnValue().Set(Nan::New(result)); } NAN_METHOD(egl::DestroyContext) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyContext, context, External); - EGLContext context = (EGLContext) External::Cast(*args[0])->Value(); + EGLContext context = (EGLContext) External::Cast(*info[0])->Value(); EGLBoolean result = eglDestroyContext(State.display, context); - NanReturnValue(NanNew(result)); + info.GetReturnValue().Set(Nan::New(result)); } diff --git a/src/openvg.cc b/src/openvg.cc index 62b1f15..dec4e0c 100755 --- a/src/openvg.cc +++ b/src/openvg.cc @@ -5,7 +5,7 @@ #include "VG/vgext.h" #include -#include +//#include #include #include "nan.h" @@ -15,179 +15,176 @@ const bool kInitOpenGLES = false; -using namespace node; -using namespace v8; - void init(Handle target) { - NODE_SET_METHOD(target, "startUp" , openvg::StartUp); - NODE_SET_METHOD(target, "shutdown" , openvg::Shutdown); + Nan::SetMethod(target, "startUp" , openvg::StartUp); + Nan::SetMethod(target, "shutdown" , openvg::Shutdown); - NODE_SET_METHOD(target, "getError" , openvg::GetError); + Nan::SetMethod(target, "getError" , openvg::GetError); - NODE_SET_METHOD(target, "flush" , openvg::Flush); - NODE_SET_METHOD(target, "finish" , openvg::Finish); + Nan::SetMethod(target, "flush" , openvg::Flush); + Nan::SetMethod(target, "finish" , openvg::Finish); /* Getters and Setters */ - NODE_SET_METHOD(target, "setF" , openvg::SetF); - NODE_SET_METHOD(target, "setI" , openvg::SetI); - NODE_SET_METHOD(target, "setFV" , openvg::SetFV); - NODE_SET_METHOD(target, "setIV" , openvg::SetIV); - NODE_SET_METHOD(target, "setFVOL" , openvg::SetFVOL); // Offset + Length - NODE_SET_METHOD(target, "setIVOL" , openvg::SetIVOL); // Offset + Length - - NODE_SET_METHOD(target, "getF" , openvg::GetF); - NODE_SET_METHOD(target, "getI" , openvg::GetI); - NODE_SET_METHOD(target, "getVectorSize" , openvg::GetVectorSize); - NODE_SET_METHOD(target, "getFV" , openvg::GetFV); - NODE_SET_METHOD(target, "getIV" , openvg::GetIV); - NODE_SET_METHOD(target, "getFVOL" , openvg::GetFVOL); // Offset + Length - NODE_SET_METHOD(target, "getIVOL" , openvg::GetIVOL); // Offset + Length - - NODE_SET_METHOD(target, "setParameterF" , openvg::SetParameterF); - NODE_SET_METHOD(target, "setParameterI" , openvg::SetParameterI); - NODE_SET_METHOD(target, "setParameterFV" , openvg::SetParameterFV); - NODE_SET_METHOD(target, "setParameterIV" , openvg::SetParameterIV); - NODE_SET_METHOD(target, "setParameterFVOL" , openvg::SetParameterFVOL); - NODE_SET_METHOD(target, "setParameterIVOL" , openvg::SetParameterIVOL); - - NODE_SET_METHOD(target, "getParameterF" , openvg::GetParameterF); - NODE_SET_METHOD(target, "getParameterI" , openvg::GetParameterI); - NODE_SET_METHOD(target, "getParameterVectorSize", openvg::GetParameterVectorSize); - NODE_SET_METHOD(target, "getParameterFV" , openvg::GetParameterFV); - NODE_SET_METHOD(target, "getParameterIV" , openvg::GetParameterIV); - NODE_SET_METHOD(target, "getParameterFVOL" , openvg::GetParameterFVOL); // Offset + Length - NODE_SET_METHOD(target, "getParameterIVOL" , openvg::GetParameterIVOL); // Offset + Length + Nan::SetMethod(target, "setF" , openvg::SetF); + Nan::SetMethod(target, "setI" , openvg::SetI); + Nan::SetMethod(target, "setFV" , openvg::SetFV); + Nan::SetMethod(target, "setIV" , openvg::SetIV); + Nan::SetMethod(target, "setFVOL" , openvg::SetFVOL); // Offset + Length + Nan::SetMethod(target, "setIVOL" , openvg::SetIVOL); // Offset + Length + + Nan::SetMethod(target, "getF" , openvg::GetF); + Nan::SetMethod(target, "getI" , openvg::GetI); + Nan::SetMethod(target, "getVectorSize" , openvg::GetVectorSize); + Nan::SetMethod(target, "getFV" , openvg::GetFV); + Nan::SetMethod(target, "getIV" , openvg::GetIV); + Nan::SetMethod(target, "getFVOL" , openvg::GetFVOL); // Offset + Length + Nan::SetMethod(target, "getIVOL" , openvg::GetIVOL); // Offset + Length + + Nan::SetMethod(target, "setParameterF" , openvg::SetParameterF); + Nan::SetMethod(target, "setParameterI" , openvg::SetParameterI); + Nan::SetMethod(target, "setParameterFV" , openvg::SetParameterFV); + Nan::SetMethod(target, "setParameterIV" , openvg::SetParameterIV); + Nan::SetMethod(target, "setParameterFVOL" , openvg::SetParameterFVOL); + Nan::SetMethod(target, "setParameterIVOL" , openvg::SetParameterIVOL); + + Nan::SetMethod(target, "getParameterF" , openvg::GetParameterF); + Nan::SetMethod(target, "getParameterI" , openvg::GetParameterI); + Nan::SetMethod(target, "getParameterVectorSize", openvg::GetParameterVectorSize); + Nan::SetMethod(target, "getParameterFV" , openvg::GetParameterFV); + Nan::SetMethod(target, "getParameterIV" , openvg::GetParameterIV); + Nan::SetMethod(target, "getParameterFVOL" , openvg::GetParameterFVOL); // Offset + Length + Nan::SetMethod(target, "getParameterIVOL" , openvg::GetParameterIVOL); // Offset + Length /* Matrix Manipulation */ - NODE_SET_METHOD(target, "loadIdentity" , openvg::LoadIdentity); - NODE_SET_METHOD(target, "loadMatrix" , openvg::LoadMatrix); - NODE_SET_METHOD(target, "getMatrix" , openvg::GetMatrix); - NODE_SET_METHOD(target, "multMatrix" , openvg::MultMatrix); - NODE_SET_METHOD(target, "translate" , openvg::Translate); - NODE_SET_METHOD(target, "scale" , openvg::Scale); - NODE_SET_METHOD(target, "shear" , openvg::Shear); - NODE_SET_METHOD(target, "rotate" , openvg::Rotate); + Nan::SetMethod(target, "loadIdentity" , openvg::LoadIdentity); + Nan::SetMethod(target, "loadMatrix" , openvg::LoadMatrix); + Nan::SetMethod(target, "getMatrix" , openvg::GetMatrix); + Nan::SetMethod(target, "multMatrix" , openvg::MultMatrix); + Nan::SetMethod(target, "translate" , openvg::Translate); + Nan::SetMethod(target, "scale" , openvg::Scale); + Nan::SetMethod(target, "shear" , openvg::Shear); + Nan::SetMethod(target, "rotate" , openvg::Rotate); /* Masking and Clearing */ - NODE_SET_METHOD(target, "mask" , openvg::Mask); - NODE_SET_METHOD(target, "renderToMask" , openvg::RenderToMask); - NODE_SET_METHOD(target, "createMaskLayer" , openvg::CreateMaskLayer); - NODE_SET_METHOD(target, "destroyMaskLayer" , openvg::DestroyMaskLayer); - NODE_SET_METHOD(target, "fillMaskLayer" , openvg::FillMaskLayer); - NODE_SET_METHOD(target, "copyMask" , openvg::CopyMask); - NODE_SET_METHOD(target, "clear" , openvg::Clear); + Nan::SetMethod(target, "mask" , openvg::Mask); + Nan::SetMethod(target, "renderToMask" , openvg::RenderToMask); + Nan::SetMethod(target, "createMaskLayer" , openvg::CreateMaskLayer); + Nan::SetMethod(target, "destroyMaskLayer" , openvg::DestroyMaskLayer); + Nan::SetMethod(target, "fillMaskLayer" , openvg::FillMaskLayer); + Nan::SetMethod(target, "copyMask" , openvg::CopyMask); + Nan::SetMethod(target, "clear" , openvg::Clear); /* Paths */ - NODE_SET_METHOD(target, "createPath" , openvg::CreatePath); - NODE_SET_METHOD(target, "clearPath" , openvg::ClearPath); - NODE_SET_METHOD(target, "destroyPath" , openvg::DestroyPath); - NODE_SET_METHOD(target, "removePathCapabilities", + Nan::SetMethod(target, "createPath" , openvg::CreatePath); + Nan::SetMethod(target, "clearPath" , openvg::ClearPath); + Nan::SetMethod(target, "destroyPath" , openvg::DestroyPath); + Nan::SetMethod(target, "removePathCapabilities", openvg::RemovePathCapabilities); - NODE_SET_METHOD(target, "getPathCapabilities", + Nan::SetMethod(target, "getPathCapabilities", openvg::GetPathCapabilities); - NODE_SET_METHOD(target, "appendPath" , openvg::AppendPath); - NODE_SET_METHOD(target, "appendPathData" , openvg::AppendPathData); - NODE_SET_METHOD(target, "appendPathDataO" , openvg::AppendPathDataO); // Offsets - NODE_SET_METHOD(target, "modifyPathCoords" , openvg::ModifyPathCoords); - NODE_SET_METHOD(target, "transformPath" , openvg::TransformPath); - NODE_SET_METHOD(target, "interpolatePath" , openvg::InterpolatePath); - NODE_SET_METHOD(target, "pathLength" , openvg::PathLength); - NODE_SET_METHOD(target, "pointAlongPath" , openvg::PointAlongPath); - NODE_SET_METHOD(target, "pathBounds" , openvg::PathBounds); - NODE_SET_METHOD(target, "pathTransformedBounds", + Nan::SetMethod(target, "appendPath" , openvg::AppendPath); + Nan::SetMethod(target, "appendPathData" , openvg::AppendPathData); + Nan::SetMethod(target, "appendPathDataO" , openvg::AppendPathDataO); // Offsets + Nan::SetMethod(target, "modifyPathCoords" , openvg::ModifyPathCoords); + Nan::SetMethod(target, "transformPath" , openvg::TransformPath); + Nan::SetMethod(target, "interpolatePath" , openvg::InterpolatePath); + Nan::SetMethod(target, "pathLength" , openvg::PathLength); + Nan::SetMethod(target, "pointAlongPath" , openvg::PointAlongPath); + Nan::SetMethod(target, "pathBounds" , openvg::PathBounds); + Nan::SetMethod(target, "pathTransformedBounds", openvg::PathTransformedBounds); - NODE_SET_METHOD(target, "drawPath" , openvg::DrawPath); + Nan::SetMethod(target, "drawPath" , openvg::DrawPath); /* Paint */ - NODE_SET_METHOD(target, "createPaint" , openvg::CreatePaint); - NODE_SET_METHOD(target, "destroyPaint" , openvg::DestroyPaint); - NODE_SET_METHOD(target, "setPaint" , openvg::SetPaint); - NODE_SET_METHOD(target, "getPaint" , openvg::GetPaint); - NODE_SET_METHOD(target, "setColor" , openvg::SetColor); - NODE_SET_METHOD(target, "getColor" , openvg::GetColor); - NODE_SET_METHOD(target, "paintPattern" , openvg::PaintPattern); + Nan::SetMethod(target, "createPaint" , openvg::CreatePaint); + Nan::SetMethod(target, "destroyPaint" , openvg::DestroyPaint); + Nan::SetMethod(target, "setPaint" , openvg::SetPaint); + Nan::SetMethod(target, "getPaint" , openvg::GetPaint); + Nan::SetMethod(target, "setColor" , openvg::SetColor); + Nan::SetMethod(target, "getColor" , openvg::GetColor); + Nan::SetMethod(target, "paintPattern" , openvg::PaintPattern); /* Images */ - NODE_SET_METHOD(target, "createImage" , openvg::CreateImage); - NODE_SET_METHOD(target, "destroyImage" , openvg::DestroyImage); - NODE_SET_METHOD(target, "clearImage" , openvg::ClearImage); - NODE_SET_METHOD(target, "imageSubData" , openvg::ImageSubData); - NODE_SET_METHOD(target, "getImageSubData" , openvg::GetImageSubData); - NODE_SET_METHOD(target, "childImage" , openvg::ChildImage); - NODE_SET_METHOD(target, "getParent" , openvg::GetParent); - NODE_SET_METHOD(target, "copyImage" , openvg::CopyImage); - NODE_SET_METHOD(target, "drawImage" , openvg::DrawImage); - NODE_SET_METHOD(target, "setPixels" , openvg::SetPixels); - NODE_SET_METHOD(target, "writePixels" , openvg::WritePixels); - NODE_SET_METHOD(target, "getPixels" , openvg::GetPixels); - NODE_SET_METHOD(target, "readPixels" , openvg::ReadPixels); - NODE_SET_METHOD(target, "copyPixels" , openvg::CopyPixels); + Nan::SetMethod(target, "createImage" , openvg::CreateImage); + Nan::SetMethod(target, "destroyImage" , openvg::DestroyImage); + Nan::SetMethod(target, "clearImage" , openvg::ClearImage); + Nan::SetMethod(target, "imageSubData" , openvg::ImageSubData); + Nan::SetMethod(target, "getImageSubData" , openvg::GetImageSubData); + Nan::SetMethod(target, "childImage" , openvg::ChildImage); + Nan::SetMethod(target, "getParent" , openvg::GetParent); + Nan::SetMethod(target, "copyImage" , openvg::CopyImage); + Nan::SetMethod(target, "drawImage" , openvg::DrawImage); + Nan::SetMethod(target, "setPixels" , openvg::SetPixels); + Nan::SetMethod(target, "writePixels" , openvg::WritePixels); + Nan::SetMethod(target, "getPixels" , openvg::GetPixels); + Nan::SetMethod(target, "readPixels" , openvg::ReadPixels); + Nan::SetMethod(target, "copyPixels" , openvg::CopyPixels); /* Text */ - NODE_SET_METHOD(target, "createFont" , openvg::CreateFont); - NODE_SET_METHOD(target, "destroyFont" , openvg::DestroyFont); - NODE_SET_METHOD(target, "setGlyphToPath" , openvg::SetGlyphToPath); - NODE_SET_METHOD(target, "setGlyphToImage" , openvg::SetGlyphToImage); - NODE_SET_METHOD(target, "clearGlyph" , openvg::ClearGlyph); - NODE_SET_METHOD(target, "drawGlyph" , openvg::DrawGlyph); - NODE_SET_METHOD(target, "drawGlyphs" , openvg::DrawGlyphs); + Nan::SetMethod(target, "createFont" , openvg::CreateFont); + Nan::SetMethod(target, "destroyFont" , openvg::DestroyFont); + Nan::SetMethod(target, "setGlyphToPath" , openvg::SetGlyphToPath); + Nan::SetMethod(target, "setGlyphToImage" , openvg::SetGlyphToImage); + Nan::SetMethod(target, "clearGlyph" , openvg::ClearGlyph); + Nan::SetMethod(target, "drawGlyph" , openvg::DrawGlyph); + Nan::SetMethod(target, "drawGlyphs" , openvg::DrawGlyphs); /* Image Filters */ - NODE_SET_METHOD(target, "colorMatrix" , openvg::ColorMatrix); - NODE_SET_METHOD(target, "convolve" , openvg::Convolve); - NODE_SET_METHOD(target, "separableConvolve", openvg::SeparableConvolve); - NODE_SET_METHOD(target, "gaussianBlur" , openvg::GaussianBlur); - NODE_SET_METHOD(target, "lookup" , openvg::Lookup); - NODE_SET_METHOD(target, "lookupSingle" , openvg::LookupSingle); + Nan::SetMethod(target, "colorMatrix" , openvg::ColorMatrix); + Nan::SetMethod(target, "convolve" , openvg::Convolve); + Nan::SetMethod(target, "separableConvolve", openvg::SeparableConvolve); + Nan::SetMethod(target, "gaussianBlur" , openvg::GaussianBlur); + Nan::SetMethod(target, "lookup" , openvg::Lookup); + Nan::SetMethod(target, "lookupSingle" , openvg::LookupSingle); /* Hardware Queries */ - NODE_SET_METHOD(target, "hardwareQuery" , openvg::HardwareQuery); + Nan::SetMethod(target, "hardwareQuery" , openvg::HardwareQuery); /* Renderer and Extension Information */ - NODE_SET_METHOD(target, "getString" , openvg::GetString); + Nan::SetMethod(target, "getString" , openvg::GetString); /* Utilities */ - Local VGU = NanNew(); - target->Set(NanNew("vgu"), VGU); - - NODE_SET_METHOD(VGU, "line" , openvg::vgu::Line); - NODE_SET_METHOD(VGU, "polygon" , openvg::vgu::Polygon); - NODE_SET_METHOD(VGU, "rect" , openvg::vgu::Rect); - NODE_SET_METHOD(VGU, "roundRect" , openvg::vgu::RoundRect); - NODE_SET_METHOD(VGU, "ellipse" , openvg::vgu::Ellipse); - NODE_SET_METHOD(VGU, "arc" , openvg::vgu::Arc); - NODE_SET_METHOD(VGU, "computeWarpQuadToSquare", + Local VGU = Nan::New(); + Nan::Set(target, Nan::New("vgu").ToLocalChecked(), VGU); + + Nan::SetMethod(VGU, "line" , openvg::vgu::Line); + Nan::SetMethod(VGU, "polygon" , openvg::vgu::Polygon); + Nan::SetMethod(VGU, "rect" , openvg::vgu::Rect); + Nan::SetMethod(VGU, "roundRect" , openvg::vgu::RoundRect); + Nan::SetMethod(VGU, "ellipse" , openvg::vgu::Ellipse); + Nan::SetMethod(VGU, "arc" , openvg::vgu::Arc); + Nan::SetMethod(VGU, "computeWarpQuadToSquare", openvg::vgu::ComputeWarpQuadToSquare); - NODE_SET_METHOD(VGU, "computeWarpSquareToQuad", + Nan::SetMethod(VGU, "computeWarpSquareToQuad", openvg::vgu::ComputeWarpSquareToQuad); - NODE_SET_METHOD(VGU, "computeWarpQuadToQuad", + Nan::SetMethod(VGU, "computeWarpQuadToQuad", openvg::vgu::ComputeWarpQuadToQuad); /* KHR extensions */ - Local ext = NanNew(); - target->Set(NanNew("ext"), ext); + Local ext = Nan::New(); + Nan::Set(target, Nan::New("ext").ToLocalChecked(), ext); - NODE_SET_METHOD(ext, "createEGLImageTargetKHR", + Nan::SetMethod(ext, "createEGLImageTargetKHR", openvg::ext::CreateEGLImageTargetKHR); - NODE_SET_METHOD(ext, "iterativeAverageBlurKHR", + Nan::SetMethod(ext, "iterativeAverageBlurKHR", openvg::ext::IterativeAverageBlurKHR); - NODE_SET_METHOD(ext, "parametricFilterKHR", openvg::ext::ParametricFilterKHR); - NODE_SET_METHOD(ext, "dropShadowKHR" , openvg::ext::DropShadowKHR); - NODE_SET_METHOD(ext, "glowKHR" , openvg::ext::GlowKHR); - NODE_SET_METHOD(ext, "bevelKHR" , openvg::ext::BevelKHR); - NODE_SET_METHOD(ext, "gradientGlowKHR" , openvg::ext::GradientGlowKHR); - NODE_SET_METHOD(ext, "gradientBevelKHR" , openvg::ext::GradientBevelKHR); + Nan::SetMethod(ext, "parametricFilterKHR", openvg::ext::ParametricFilterKHR); + Nan::SetMethod(ext, "dropShadowKHR" , openvg::ext::DropShadowKHR); + Nan::SetMethod(ext, "glowKHR" , openvg::ext::GlowKHR); + Nan::SetMethod(ext, "bevelKHR" , openvg::ext::BevelKHR); + Nan::SetMethod(ext, "gradientGlowKHR" , openvg::ext::GradientGlowKHR); + Nan::SetMethod(ext, "gradientBevelKHR" , openvg::ext::GradientBevelKHR); - NODE_SET_METHOD(ext, "projectiveMatrixNDS", + Nan::SetMethod(ext, "projectiveMatrixNDS", openvg::ext::ProjectiveMatrixNDS); - NODE_SET_METHOD(ext, "transformClipLineNDS", + Nan::SetMethod(ext, "transformClipLineNDS", openvg::ext::TransformClipLineNDS); /* EGL */ - Local egl = NanNew(); - target->Set(NanNew("egl"), egl); + Local egl = Nan::New(); + Nan::Set(target, Nan::New("egl").ToLocalChecked(), egl); egl::InitBindings(egl); } NODE_MODULE(openvg, init) @@ -201,48 +198,8 @@ NODE_MODULE(openvg, init) }\ } -#if NODE_MODULE_VERSION <= NODE_0_10_MODULE_VERSION -template class TypedArrayWrapper { - private: - Local array; - Handle buffer; - int byteOffset; - public: - NAN_INLINE TypedArrayWrapper(const Local& arg) : - array(arg->ToObject()), - buffer(array->Get(NanNew("buffer"))->ToObject()), - byteOffset(array->Get(NanNew("byteOffset"))->Int32Value()) { - } - - NAN_INLINE C* pointer(int offset = 0) { - return (C*) &((char*) buffer->GetIndexedPropertiesExternalArrayData())[byteOffset + offset]; - } - - NAN_INLINE int length() { - return array->Get(NanNew("length"))->Uint32Value(); - } -}; -#else -template class TypedArrayWrapper { - private: - Local array; - public: - NAN_INLINE TypedArrayWrapper(const Local& arg) : - array(Handle::Cast(arg->ToObject())) { - } - - NAN_INLINE C* pointer(int offset = 0) { - return (C*) &((char*) array->BaseAddress())[offset]; - } - - NAN_INLINE int length() { - return array->Length(); - } -}; -#endif - NAN_METHOD(openvg::StartUp) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(startUp, screen, Object); @@ -254,54 +211,50 @@ NAN_METHOD(openvg::StartUp) { CHECK_VG_ERROR; - Local screen = args[0].As(); - screen->Set(NanNew("width" ), NanNew(egl::State.screen_width)); - screen->Set(NanNew("height"), NanNew(egl::State.screen_height)); - screen->Set(NanNew("display"), NanNew(egl::State.display)); - screen->Set(NanNew("surface"), NanNew(egl::State.surface)); - screen->Set(NanNew("context"), NanNew(egl::State.context)); - - NanReturnUndefined(); + Local screen = info[0].As(); + screen->Set(Nan::New("width").ToLocalChecked(), Nan::New(egl::State.screen_width)); + screen->Set(Nan::New("height").ToLocalChecked(), Nan::New(egl::State.screen_height)); + screen->Set(Nan::New("display").ToLocalChecked(), Nan::New(egl::State.display)); + screen->Set(Nan::New("surface").ToLocalChecked(), Nan::New(egl::State.surface)); + screen->Set(Nan::New("context").ToLocalChecked(), Nan::New(egl::State.context)); } NAN_METHOD(openvg::Shutdown) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(shutdown); egl::Finish(); - - NanReturnUndefined(); } NAN_METHOD(openvg::GetError) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(getError); - NanReturnValue(NanNew(vgGetError())); + info.GetReturnValue().Set(Nan::New(vgGetError())); } NAN_METHOD(openvg::Flush) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(flush); vgFlush(); - NanReturnUndefined(); + } NAN_METHOD(openvg::Finish) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(finish); vgFinish(); - NanReturnUndefined(); + } @@ -309,345 +262,343 @@ NAN_METHOD(openvg::Finish) { NAN_METHOD(openvg::SetF) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setF, type, Int32, value, Number); - vgSetf((VGParamType) args[0]->Int32Value(), - (VGfloat) args[1]->NumberValue()); + vgSetf((VGParamType) info[0]->Int32Value(), + (VGfloat) info[1]->NumberValue()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetI) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setI, type, Int32, value, Int32); - vgSeti((VGParamType) args[0]->Int32Value(), - (VGint) args[1]->Int32Value()); + vgSeti((VGParamType) info[0]->Int32Value(), + (VGint) info[1]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetFV) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setFV, type, Int32, Float32Array, Object); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents data(info[1]); - vgSetfv((VGParamType) args[0]->Int32Value(), - values.length(), - values.pointer()); + vgSetfv((VGParamType) info[0]->Int32Value(), + data.length(), + (*data)); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetIV) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setIV, type, Int32, Int32Array, Object); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgSetiv((VGParamType) args[0]->Int32Value(), + vgSetiv((VGParamType) info[0]->Int32Value(), values.length(), - values.pointer()); + *values); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetFVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(setFVOL, type, Int32, Float32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgSetfv((VGParamType) args[0]->Int32Value(), - (VGint) args[3]->Int32Value(), - values.pointer(args[2]->Int32Value())); + vgSetfv((VGParamType) info[0]->Int32Value(), + (VGint) info[3]->Int32Value(), + (*values) + info[2]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetIVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(setIV, type, Int32, Int32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[1]); - - vgSetiv((VGParamType) args[0]->Int32Value(), - (VGint) args[3]->Int32Value(), - values.pointer(args[2]->Int32Value())); + Nan::TypedArrayContents values(info[1]); - NanReturnUndefined(); + vgSetiv((VGParamType) info[0]->Int32Value(), + (VGint) info[3]->Int32Value(), + (*values) + info[2]->Int32Value()); } NAN_METHOD(openvg::GetF) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getF, type, Int32); - NanReturnValue(NanNew(vgGetf((VGParamType) args[0]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetf((VGParamType) info[0]->Int32Value()))); } NAN_METHOD(openvg::GetI) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getI, type, Int32); - NanReturnValue(NanNew(vgGeti((VGParamType) args[0]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGeti((VGParamType) info[0]->Int32Value()))); } NAN_METHOD(openvg::GetVectorSize) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getVectorSize, type, Int32); - NanReturnValue(NanNew(vgGetVectorSize((VGParamType) args[0]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetVectorSize((VGParamType) info[0]->Int32Value()))); } NAN_METHOD(openvg::GetFV) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(getFV, type, Int32, Float32Array, Object); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgGetfv((VGParamType) args[0]->Int32Value(), + vgGetfv((VGParamType) info[0]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetIV) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(getIV, type, Int32, Float32Array, Object); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgGetiv((VGParamType) args[0]->Int32Value(), + vgGetiv((VGParamType) info[0]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetFVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(getFV, type, Int32, Float32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgGetfv((VGParamType) args[0]->Int32Value(), - (VGint) args[3]->Int32Value(), - values.pointer(args[2]->Int32Value())); + vgGetfv((VGParamType) info[0]->Int32Value(), + (VGint) info[3]->Int32Value(), + (*values) + info[2]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetIVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(getIV, type, Int32, Float32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[1]); + Nan::TypedArrayContents values(info[1]); - vgGetiv((VGParamType) args[0]->Int32Value(), - (VGint) args[3]->Int32Value(), - values.pointer(args[2]->Int32Value())); + vgGetiv((VGParamType) info[0]->Int32Value(), + (VGint) info[3]->Int32Value(), + (*values) + info[2]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterF) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(setParameterF, VGHandle, Int32, VGParamType, Int32, value, Number); - vgSetParameterf((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGfloat) args[2]->NumberValue()); + vgSetParameterf((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGfloat) info[2]->NumberValue()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterI) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(setParameterI, VGHandle, Int32, VGParamType, Int32, value, Int32); - vgSetParameteri((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGint) args[2]->Int32Value()); + vgSetParameteri((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGint) info[2]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterFV) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(setParameterFV, VGHandle, Int32, VGParamType, Int32, Float32Array, Object); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgSetParameterfv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), + vgSetParameterfv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterIV) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(setParameterIV, VGHandle, Int32, VGParamType, Int32, Int32Array, Object); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgSetParameteriv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), + vgSetParameteriv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterFVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(setParameterFV, VGHandle, Int32, VGParamType, Int32, Float32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgSetParameterfv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGint) args[4]->Int32Value(), - values.pointer(args[3]->Int32Value())); + vgSetParameterfv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGint) info[4]->Int32Value(), + (*values) + info[3]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetParameterIVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(setParameterIV, VGHandle, Int32, VGParamType, Int32, Int32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgSetParameteriv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGint) args[4]->Int32Value(), - values.pointer(args[3]->Int32Value())); + vgSetParameteriv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGint) info[4]->Int32Value(), + (*values) + info[3]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetParameterF) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(getParameterF, VGHandle, Int32, VGParamType, Int32); - NanReturnValue(NanNew(vgGetParameterf((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetParameterf((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value()))); } NAN_METHOD(openvg::GetParameterI) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(getParameterI, VGHandle, Int32, VGParamType, Int32); - NanReturnValue(NanNew(vgGetParameteri((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetParameteri((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value()))); } NAN_METHOD(openvg::GetParameterVectorSize) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(getParameterVectorSize, VGHandle, Int32, VGParamType, Int32); - NanReturnValue(NanNew(vgGetParameterVectorSize((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetParameterVectorSize((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value()))); } NAN_METHOD(openvg::GetParameterFV) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(getParameterFV, VGHandle, Int32, VGParamType, Int32, Float32Array, Object); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgGetParameterfv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), + vgGetParameterfv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetParameterIV) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(getParameterIV, VGHandle, Int32, VGParamType, Int32, Int32Array, Object); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgGetParameteriv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), + vgGetParameteriv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), values.length(), - values.pointer()); + (*values)); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetParameterFVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(getParameterFV, VGHandle, Int32, VGParamType, Int32, Float32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgGetParameterfv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGint) args[4]->Int32Value(), - values.pointer(args[3]->Int32Value())); + vgGetParameterfv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGint) info[4]->Int32Value(), + (*values) + info[3]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetParameterIVOL) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(getParameterIV, VGHandle, Int32, VGParamType, Int32, Int32Array, Object, offset, Int32, length, Int32); - TypedArrayWrapper values(args[2]); + Nan::TypedArrayContents values(info[2]); - vgGetParameteriv((VGHandle) args[0]->Int32Value(), - (VGParamType) args[1]->Int32Value(), - (VGint) args[4]->Int32Value(), - values.pointer(args[3]->Int32Value())); + vgGetParameteriv((VGHandle) info[0]->Int32Value(), + (VGParamType) info[1]->Int32Value(), + (VGint) info[4]->Int32Value(), + (*values) + info[3]->Int32Value()); - NanReturnUndefined(); + } @@ -655,92 +606,92 @@ NAN_METHOD(openvg::GetParameterIVOL) { NAN_METHOD(openvg::LoadIdentity) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(loadIdentity); vgLoadIdentity(); - NanReturnUndefined(); + } NAN_METHOD(openvg::LoadMatrix) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(loadIdentity, Float32Array, Object); - TypedArrayWrapper matrix(args[0]); + Nan::TypedArrayContents matrix(info[0]); - vgLoadMatrix(matrix.pointer()); + vgLoadMatrix(*matrix); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetMatrix) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getMatrix, Float32Array, Object); - TypedArrayWrapper matrix(args[0]); + Nan::TypedArrayContents matrix(info[0]); - vgGetMatrix(matrix.pointer()); + vgGetMatrix(*matrix); - NanReturnUndefined(); + } NAN_METHOD(openvg::MultMatrix) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(multMatrix, Float32Array, Object); - TypedArrayWrapper matrix(args[0]); + Nan::TypedArrayContents matrix(info[0]); - vgMultMatrix(matrix.pointer()); + vgMultMatrix(*matrix); - NanReturnUndefined(); + } NAN_METHOD(openvg::Translate) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(translate, x, Number, y, Number); - vgTranslate((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue()); + vgTranslate((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue()); - NanReturnUndefined(); + } NAN_METHOD(openvg::Scale) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(scale, x, Number, y, Number); - vgScale((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue()); + vgScale((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue()); - NanReturnUndefined(); + } NAN_METHOD(openvg::Shear) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(shear, x, Number, y, Number); - vgShear((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue()); + vgShear((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue()); - NanReturnUndefined(); + } NAN_METHOD(openvg::Rotate) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(shear, angle, Number); - vgRotate((VGfloat) args[0]->NumberValue()); + vgRotate((VGfloat) info[0]->NumberValue()); - NanReturnUndefined(); + } @@ -748,99 +699,93 @@ NAN_METHOD(openvg::Rotate) { NAN_METHOD(openvg::Mask) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(mask, VGHandle, Uint32, VGMaskOperation, Uint32, x, Int32, y, Int32, width, Int32, height, Int32); - vgMask((VGHandle) args[0]->Uint32Value(), - static_cast(args[1]->Uint32Value()), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value()); + vgMask((VGHandle) info[0]->Uint32Value(), + static_cast(info[1]->Uint32Value()), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::RenderToMask) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(renderToMask, VGPath, Uint32, VGbitfield, Uint32, VGMaskOperation, Uint32); - vgRenderToMask((VGPath) args[0]->Uint32Value(), - (VGbitfield) args[1]->Uint32Value(), - (VGMaskOperation) args[2]->Uint32Value()); + vgRenderToMask((VGPath) info[0]->Uint32Value(), + (VGbitfield) info[1]->Uint32Value(), + (VGMaskOperation) info[2]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::CreateMaskLayer) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(createMaskLayer, width, Int32, height, Int32); - NanReturnValue(NanNew(vgCreateMaskLayer((VGint) args[0]->Int32Value(), - (VGint) args[1]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgCreateMaskLayer((VGint) info[0]->Int32Value(), + (VGint) info[1]->Int32Value()))); } NAN_METHOD(openvg::DestroyMaskLayer) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyMaskLayer, VGMaskLayer, Uint32); - vgDestroyMaskLayer((VGMaskLayer) args[0]->Uint32Value()); - - NanReturnUndefined(); + vgDestroyMaskLayer((VGMaskLayer) info[0]->Uint32Value()); } NAN_METHOD(openvg::FillMaskLayer) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(fillMaskLayer, VGMaskLayer, Uint32, x, Int32, y, Int32, width, Int32, height, Int32, value, Number); - vgFillMaskLayer((VGMaskLayer) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGfloat) args[5]->NumberValue()); - - NanReturnUndefined(); + vgFillMaskLayer((VGMaskLayer) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGfloat) info[5]->NumberValue()); } NAN_METHOD(openvg::CopyMask) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(fillMaskLayer, VGMaskLayer, Uint32, dx, Int32, dy, Int32, sx, Int32, sy, Int32, width, Int32, height, Int32); - vgCopyMask((VGMaskLayer) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), (VGint) args[6]->Int32Value()); - - NanReturnUndefined(); + vgCopyMask((VGMaskLayer) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), (VGint) info[6]->Int32Value()); } NAN_METHOD(openvg::Clear) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(clear, x, Int32, y, Int32, width, Int32, height, Int32); - vgClear((VGint) args[0]->Int32Value(), (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), (VGint) args[3]->Int32Value()); + vgClear((VGint) info[0]->Int32Value(), (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), (VGint) info[3]->Int32Value()); - NanReturnUndefined(); + } @@ -848,163 +793,155 @@ NAN_METHOD(openvg::Clear) { NAN_METHOD(openvg::CreatePath) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(createPath, pathFormat, Int32, VGPathDatatype, Uint32, scale, Number, bias, Number, segmentCapacityHint, Int32, coordCapacityHint, Int32, capabilities, Uint32); - NanReturnValue(NanNew(vgCreatePath((VGint) args[0]->Int32Value(), - static_cast(args[1]->Uint32Value()), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGbitfield) args[6]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vgCreatePath((VGint) info[0]->Int32Value(), + static_cast(info[1]->Uint32Value()), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGbitfield) info[6]->Uint32Value()))); } NAN_METHOD(openvg::ClearPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(clearPath, VGPath, Number, capabilities, Uint32); - vgClearPath((VGPath) args[0]->Uint32Value(), - (VGbitfield) args[1]->Uint32Value()); + vgClearPath((VGPath) info[0]->Uint32Value(), + (VGbitfield) info[1]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::DestroyPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyPath, VGPath, Number); - vgDestroyPath((VGPath) args[0]->Uint32Value()); + vgDestroyPath((VGPath) info[0]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::RemovePathCapabilities) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(removePathCapabilities, VGPath, Number, capabilities, Uint32); - vgRemovePathCapabilities((VGPath) args[0]->Uint32Value(), - (VGbitfield) args[1]->Uint32Value()); + vgRemovePathCapabilities((VGPath) info[0]->Uint32Value(), + (VGbitfield) info[1]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::GetPathCapabilities) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getPathCapabilities, VGPath, Number); - NanReturnValue(NanNew(vgGetPathCapabilities((VGPath) args[0]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetPathCapabilities((VGPath) info[0]->Int32Value()))); } NAN_METHOD(openvg::AppendPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(appendPath, dstPath, Number, srcPath, Number); - vgAppendPath((VGPath) args[0]->Uint32Value(), - (VGPath) args[1]->Uint32Value()); + vgAppendPath((VGPath) info[0]->Uint32Value(), + (VGPath) info[1]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::AppendPathData) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(appendPathData, dstPath, Number, numSegments, Int32, Uint8Array, Object, pathData, Object); - TypedArrayWrapper segments(args[2]); - TypedArrayWrapper data(args[3]); + Nan::TypedArrayContents segments(info[2]); + Nan::TypedArrayContents data(info[3]); - vgAppendPathData((VGPath) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - segments.pointer(), - data.pointer()); - - NanReturnUndefined(); + vgAppendPathData((VGPath) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (*segments), + (*data)); } NAN_METHOD(openvg::AppendPathDataO) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(appendPathData, dstPath, Number, numSegments, Int32, Uint8Array, Object, pathData, Object); - TypedArrayWrapper segments(args[2]); - TypedArrayWrapper data(args[4]); - - vgAppendPathData((VGPath) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - segments.pointer(args[3]->Uint32Value()), - data.pointer(args[5]->Int32Value())); + Nan::TypedArrayContents segments(info[2]); + Nan::TypedArrayContents data(info[4]); - NanReturnUndefined(); + vgAppendPathData((VGPath) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (*segments) + info[3]->Uint32Value(), + (*data) + info[5]->Int32Value()); } NAN_METHOD(openvg::ModifyPathCoords) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(modifyPathCoords, VGPath, Number, startIndex, Int32, numSegments, Int32, pathData, Object); - TypedArrayWrapper data(args[3]); + Nan::TypedArrayContents data(info[3]); - vgModifyPathCoords((VGPath) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - data.pointer()); - - NanReturnUndefined(); + vgModifyPathCoords((VGPath) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (*data)); } NAN_METHOD(openvg::TransformPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(transformPath, dstPath, Number, srcPath, Number); - vgTransformPath((VGPath) args[0]->Uint32Value(), - (VGPath) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgTransformPath((VGPath) info[0]->Uint32Value(), + (VGPath) info[1]->Uint32Value()); } NAN_METHOD(openvg::InterpolatePath) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(interpolatePath, dstPath, Number, startPath, Number, endPath, Number, amount, Number); - NanReturnValue(NanNew(vgInterpolatePath((VGPath) args[0]->Uint32Value(), - (VGPath) args[1]->Uint32Value(), - (VGPath) args[2]->Uint32Value(), - (VGfloat) args[3]->NumberValue()))); + info.GetReturnValue().Set(Nan::New(vgInterpolatePath((VGPath) info[0]->Uint32Value(), + (VGPath) info[1]->Uint32Value(), + (VGPath) info[2]->Uint32Value(), + (VGfloat) info[3]->NumberValue()))); } NAN_METHOD(openvg::PathLength) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(pathLength, path, Number, startSegment, Int32, numSegments, Int32); - NanReturnValue(NanNew(vgPathLength((VGPath) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgPathLength((VGPath) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value()))); } NAN_METHOD(openvg::PointAlongPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(pointAlongPath, path, Number, startSegment, Int32, numSegments, Int32, @@ -1012,68 +949,60 @@ NAN_METHOD(openvg::PointAlongPath) { VGfloat x, y, tx, ty; - vgPointAlongPath((VGPath) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGfloat) args[3]->NumberValue(), + vgPointAlongPath((VGPath) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGfloat) info[3]->NumberValue(), &x, &y, &tx, &ty); - Local point = args[4].As(); - point->Set(NanNew("x"), NanNew(x)); - point->Set(NanNew("y"), NanNew(y)); - point->Set(NanNew("tx"), NanNew(tx)); - point->Set(NanNew("ty"), NanNew(ty)); - - NanReturnUndefined(); + Local point = info[4].As(); + point->Set(Nan::New("x").ToLocalChecked(), Nan::New(x)); + point->Set(Nan::New("y").ToLocalChecked(), Nan::New(y)); + point->Set(Nan::New("tx").ToLocalChecked(), Nan::New(tx)); + point->Set(Nan::New("ty").ToLocalChecked(), Nan::New(ty)); } NAN_METHOD(openvg::PathBounds) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(pathBounds, VGPath, Number, bounds, Object); VGfloat minX, minY, width, height; - vgPathBounds((VGPath) args[0]->Uint32Value(), + vgPathBounds((VGPath) info[0]->Uint32Value(), &minX, &minY, &width, &height); - Local bounds = args[1].As(); - bounds->Set(NanNew("x"), NanNew(minX)); - bounds->Set(NanNew("y"), NanNew(minY)); - bounds->Set(NanNew("w"), NanNew(width)); - bounds->Set(NanNew("h"), NanNew(height)); - - NanReturnUndefined(); + Local bounds = info[1].As(); + bounds->Set(Nan::New("x").ToLocalChecked(), Nan::New(minX)); + bounds->Set(Nan::New("y").ToLocalChecked(), Nan::New(minY)); + bounds->Set(Nan::New("w").ToLocalChecked(), Nan::New(width)); + bounds->Set(Nan::New("h").ToLocalChecked(), Nan::New(height)); } NAN_METHOD(openvg::PathTransformedBounds) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(pathTransformedBounds, VGPath, Number, bounds, Object); VGfloat minX, minY, width, height; - vgPathTransformedBounds((VGPath) args[0]->Uint32Value(), + vgPathTransformedBounds((VGPath) info[0]->Uint32Value(), &minX, &minY, &width, &height); - Local bounds = args[1].As(); - bounds->Set(NanNew("x"), NanNew(minX)); - bounds->Set(NanNew("y"), NanNew(minY)); - bounds->Set(NanNew("w"), NanNew(width)); - bounds->Set(NanNew("h"), NanNew(height)); - - NanReturnUndefined(); + Local bounds = info[1].As(); + bounds->Set(Nan::New("x").ToLocalChecked(), Nan::New(minX)); + bounds->Set(Nan::New("y").ToLocalChecked(), Nan::New(minY)); + bounds->Set(Nan::New("w").ToLocalChecked(), Nan::New(width)); + bounds->Set(Nan::New("h").ToLocalChecked(), Nan::New(height)); } NAN_METHOD(openvg::DrawPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(drawPath, VGPath, Number, paintModes, Number); - vgDrawPath((VGPath) args[0]->Uint32Value(), - (VGbitfield) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgDrawPath((VGPath) info[0]->Uint32Value(), + (VGbitfield) info[1]->Uint32Value()); } @@ -1081,70 +1010,64 @@ NAN_METHOD(openvg::DrawPath) { NAN_METHOD(openvg::CreatePaint) { - NanScope(); + Nan::HandleScope scope; CheckArgs0(createPaint); - NanReturnValue(NanNew(vgCreatePaint())); + info.GetReturnValue().Set(Nan::New(vgCreatePaint())); } NAN_METHOD(openvg::DestroyPaint) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyPaint, VGPaint, Number); - vgDestroyPaint((VGPaint) args[0]->Uint32Value()); + vgDestroyPaint((VGPaint) info[0]->Uint32Value()); - NanReturnUndefined(); + } NAN_METHOD(openvg::SetPaint) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setPaint, VGPaint, Number, paintModes, Number); - vgSetPaint((VGPaint) args[0]->Uint32Value(), - (VGbitfield) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgSetPaint((VGPaint) info[0]->Uint32Value(), + (VGbitfield) info[1]->Uint32Value()); } NAN_METHOD(openvg::GetPaint) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getPaint, VGPaint, Uint32); - NanReturnValue(NanNew(vgGetPaint(static_cast(args[0]->Uint32Value())))); + info.GetReturnValue().Set(Nan::New(vgGetPaint(static_cast(info[0]->Uint32Value())))); } NAN_METHOD(openvg::SetColor) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(setColor, VGPaint, Uint32, rgba, Uint32); - vgSetColor((VGPaint) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgSetColor((VGPaint) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value()); } NAN_METHOD(openvg::GetColor) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getColor, VGPaint, Uint32); - NanReturnValue(NanNew(vgGetColor((VGPaint) args[0]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetColor((VGPaint) info[0]->Uint32Value()))); } NAN_METHOD(openvg::PaintPattern) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(paintPattern, VGPaint, Uint32, VGImage, Uint32); - vgPaintPattern((VGPaint) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgPaintPattern((VGPaint) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value()); } @@ -1152,191 +1075,177 @@ NAN_METHOD(openvg::PaintPattern) { NAN_METHOD(openvg::CreateImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(createImage, VGImageFormat, Uint32, width, Int32, height, Int32, allowedQuality, Uint32); - NanReturnValue(NanNew(vgCreateImage(static_cast(args[0]->Uint32Value()), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGuint) args[3]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vgCreateImage(static_cast(info[0]->Uint32Value()), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGuint) info[3]->Uint32Value()))); } NAN_METHOD(openvg::DestroyImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyImage, VGImage, Number); - vgDestroyImage((VGImage) (VGPaint) args[0]->Uint32Value()); - - NanReturnUndefined(); + vgDestroyImage((VGImage) (VGPaint) info[0]->Uint32Value()); } NAN_METHOD(openvg::ClearImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(clearImage, VGImage, Number, x, Int32, y, Int32, width, Int32, height, Int32); - vgClearImage((VGImage) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value()); - - NanReturnUndefined(); + vgClearImage((VGImage) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value()); } NAN_METHOD(openvg::ImageSubData) { - NanScope(); + Nan::HandleScope scope; CheckArgs8(imageSubData, VGImage, Number, data, Object, dataStride, Int32, dataFormat, Uint32, x, Int32, y, Int32, width, Int32, height, Int32); - Local data = args[1]->ToObject(); + Local data = info[1]->ToObject(); void *dataPointer; - Local nativeBuffer = data->Get(NanNew("buffer")); + Local nativeBuffer = data->Get(Nan::New("buffer").ToLocalChecked()); if (!nativeBuffer->IsUndefined()) { // Native array - Handle dataBuffer = nativeBuffer->ToObject(); - dataPointer = (void*) dataBuffer->GetIndexedPropertiesExternalArrayData(); + //Handle dataBuffer = nativeBuffer->ToObject(); + //dataPointer = (void*) dataBuffer->GetIndexedPropertiesExternalArrayData(); + printf("openvg.cc:%d: Should not happen?\n", __LINE__); + exit(1); } else { // Node buffer - dataPointer = (void *) Buffer::Data(data); + dataPointer = (void *) node::Buffer::Data(data); } - vgImageSubData((VGImage) args[0]->Uint32Value(), + vgImageSubData((VGImage) info[0]->Uint32Value(), dataPointer, - (VGint) args[2]->Int32Value(), - static_cast(args[3]->Uint32Value()), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value(), - (VGint) args[7]->Int32Value()); - - NanReturnUndefined(); + (VGint) info[2]->Int32Value(), + static_cast(info[3]->Uint32Value()), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value(), + (VGint) info[7]->Int32Value()); } NAN_METHOD(openvg::GetImageSubData) { - NanScope(); + Nan::HandleScope scope; CheckArgs8(getImageSubData, VGImage, Number, data, Object, dataStride, Int32, dataFormat, Uint32, x, Int32, y, Int32, width, Int32, height, Int32); - TypedArrayWrapper data(args[1]); + Nan::TypedArrayContents data(info[1]); - vgGetImageSubData((VGImage) args[0]->Uint32Value(), - data.pointer(), - (VGint) args[2]->Int32Value(), - static_cast(args[3]->Uint32Value()), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value(), - (VGint) args[7]->Int32Value()); - - NanReturnUndefined(); + vgGetImageSubData((VGImage) info[0]->Uint32Value(), + (*data), + (VGint) info[2]->Int32Value(), + static_cast(info[3]->Uint32Value()), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value(), + (VGint) info[7]->Int32Value()); } NAN_METHOD(openvg::ChildImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(childImage, VGImage, Number, x, Int32, y, Int32, width, Int32, height, Int32); - NanReturnValue(NanNew(vgChildImage((VGImage) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgChildImage((VGImage) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value()))); } NAN_METHOD(openvg::GetParent) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getParent, VGImage, Number); - NanReturnValue(NanNew(vgGetParent((VGImage) args[0]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vgGetParent((VGImage) info[0]->Uint32Value()))); } NAN_METHOD(openvg::CopyImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(copyImage, dstImage, Number, dx, Int32, dy, Int32, srcImage, Number, sx, Int32, sy, Int32, width, Int32, height, Int32, dither, Boolean); - vgCopyImage((VGImage) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGImage) args[3]->Uint32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value(), - (VGint) args[7]->Int32Value(), - (VGboolean) args[8]->BooleanValue()); - - NanReturnUndefined(); + vgCopyImage((VGImage) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGImage) info[3]->Uint32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value(), + (VGint) info[7]->Int32Value(), + (VGboolean) info[8]->BooleanValue()); } NAN_METHOD(openvg::DrawImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(drawImage, VGImage, Number); - vgDrawImage((VGImage) args[0]->Uint32Value()); - - NanReturnUndefined(); + vgDrawImage((VGImage) info[0]->Uint32Value()); } NAN_METHOD(openvg::SetPixels) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(setPixels, dx, Int32, dy, Int32, srcImage, Number, dx, Int32, dy, Int32, width, Int32, height, Int32); - vgSetPixels((VGint) args[0]->Int32Value(), - (VGint) args[1]->Int32Value(), - (VGImage) args[2]->Uint32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value()); - - NanReturnUndefined(); + vgSetPixels((VGint) info[0]->Int32Value(), + (VGint) info[1]->Int32Value(), + (VGImage) info[2]->Uint32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value()); } NAN_METHOD(openvg::WritePixels) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(writePixels, data, Object, dataStride, Int32, dataFormat, Uint32, dx, Int32, dy, Int32, width, Int32, height, Int32); - TypedArrayWrapper data(args[0]); + Nan::TypedArrayContents data(info[0]); - vgWritePixels(data.pointer(), - (VGint) args[1]->Int32Value(), - static_cast(args[2]->Uint32Value()), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value()); - - NanReturnUndefined(); + vgWritePixels((*data), + (VGint) info[1]->Int32Value(), + static_cast(info[2]->Uint32Value()), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value()); } NAN_METHOD(openvg::GetPixels) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(getPixels, VGImage, Number, @@ -1344,52 +1253,46 @@ NAN_METHOD(openvg::GetPixels) { sx, Int32, sy, Int32, width, Int32, height, Int32); - vgGetPixels((VGImage) args[0]->Uint32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value()); - - NanReturnUndefined(); + vgGetPixels((VGImage) info[0]->Uint32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value()); } NAN_METHOD(openvg::ReadPixels) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(readPixels, data, Object, dataStride, Int32, dataFormat, Uint32, sx, Int32, sy, Int32, width, Int32, height, Int32); - TypedArrayWrapper data(args[0]); - - vgReadPixels(data.pointer(), - (VGint) args[1]->Int32Value(), - static_cast(args[2]->Uint32Value()), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - (VGint) args[6]->Int32Value()); + Nan::TypedArrayContents data(info[0]); - NanReturnUndefined(); + vgReadPixels((*data), + (VGint) info[1]->Int32Value(), + static_cast(info[2]->Uint32Value()), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (VGint) info[6]->Int32Value()); } NAN_METHOD(openvg::CopyPixels) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(copyPixels, dx, Int32, dy, Int32, sx, Int32, sy, Int32, width, Int32, height, Int32); - vgCopyPixels((VGint) args[0]->Int32Value(), - (VGint) args[1]->Int32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value()); - - NanReturnUndefined(); + vgCopyPixels((VGint) info[0]->Int32Value(), + (VGint) info[1]->Int32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value()); } @@ -1397,107 +1300,95 @@ NAN_METHOD(openvg::CopyPixels) { NAN_METHOD(openvg::CreateFont) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(createFont, glyphCapacityHint, Int32); - NanReturnValue(NanNew(vgCreateFont((VGint) args[0]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgCreateFont((VGint) info[0]->Int32Value()))); } NAN_METHOD(openvg::DestroyFont) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(destroyFont, VGFont, Number); - vgDestroyFont((VGFont) args[0]->Uint32Value()); - - NanReturnUndefined(); + vgDestroyFont((VGFont) info[0]->Uint32Value()); } NAN_METHOD(openvg::SetGlyphToPath) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(setGlyphToPath, VGFont, Number, glyphIndex, Number, VGPath, Number, isHinted, Boolean, glyphOrigin, Object, escapement, Object); - TypedArrayWrapper glyphOrigin(args[4]); - TypedArrayWrapper escapement(args[5]); + Nan::TypedArrayContents glyphOrigin(info[4]); + Nan::TypedArrayContents escapement(info[5]); - vgSetGlyphToPath((VGFont) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value(), - (VGPath) args[2]->Uint32Value(), - (VGboolean) args[3]->BooleanValue(), - glyphOrigin.pointer(), - escapement.pointer()); - - NanReturnUndefined(); + vgSetGlyphToPath((VGFont) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value(), + (VGPath) info[2]->Uint32Value(), + (VGboolean) info[3]->BooleanValue(), + (*glyphOrigin), + (*escapement)); } NAN_METHOD(openvg::SetGlyphToImage) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(setGlyphToImage, VGFont, Number, glyphIndex, Number, VGImage, Number, glyphOrigin, Object, escapement, Object); - TypedArrayWrapper glyphOrigin(args[3]); - TypedArrayWrapper escapement(args[4]); - - vgSetGlyphToImage((VGFont) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value(), - (VGImage) args[2]->Uint32Value(), - glyphOrigin.pointer(), - escapement.pointer()); + Nan::TypedArrayContents glyphOrigin(info[3]); + Nan::TypedArrayContents escapement(info[4]); - NanReturnUndefined(); + vgSetGlyphToImage((VGFont) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value(), + (VGImage) info[2]->Uint32Value(), + (*glyphOrigin), + (*escapement)); } NAN_METHOD(openvg::ClearGlyph) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(clearGlyph, VGFont, Number, glyphIndex, Uint32); - vgClearGlyph((VGFont) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value()); - - NanReturnUndefined(); + vgClearGlyph((VGFont) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value()); } NAN_METHOD(openvg::DrawGlyph) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(drawGlyph, VGFont, Number, glyphIndex, Uint32, paintModes, Uint32, allowAutoHinting, Boolean); - vgDrawGlyph((VGFont) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value(), - (VGbitfield) args[2]->Uint32Value(), - (VGboolean) args[3]->BooleanValue()); - - NanReturnUndefined(); + vgDrawGlyph((VGFont) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value(), + (VGbitfield) info[2]->Uint32Value(), + (VGboolean) info[3]->BooleanValue()); } NAN_METHOD(openvg::DrawGlyphs) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(drawGlyphs, VGFont, Number, glyphCount, Int32, glyphIndices, Object, adjustments_x, Object, adjustments_y, Object, paintModes, Uint32, allowAutoHinting, Boolean); - TypedArrayWrapper glyphIndices(args[2]); - TypedArrayWrapper adjustments_x(args[3]); - TypedArrayWrapper adjustments_y(args[4]); - - vgDrawGlyphs((VGFont) args[0]->Uint32Value(), - (VGuint) args[1]->Uint32Value(), - glyphIndices.pointer(), - adjustments_x.pointer(), - adjustments_y.pointer(), - (VGbitfield) args[5]->Uint32Value(), - (VGboolean) args[6]->BooleanValue()); + Nan::TypedArrayContents glyphIndices(info[2]); + Nan::TypedArrayContents adjustments_x(info[3]); + Nan::TypedArrayContents adjustments_y(info[4]); - NanReturnUndefined(); + vgDrawGlyphs((VGFont) info[0]->Uint32Value(), + (VGuint) info[1]->Uint32Value(), + (*glyphIndices), + (*adjustments_x), + (*adjustments_y), + (VGbitfield) info[5]->Uint32Value(), + (VGboolean) info[6]->BooleanValue()); } @@ -1505,22 +1396,22 @@ NAN_METHOD(openvg::DrawGlyphs) { NAN_METHOD(openvg::ColorMatrix) { - NanScope(); + Nan::HandleScope scope; CheckArgs3(colorMatrix, dstVGImage, Number, srcVGImage, Number, matrix, Object); - TypedArrayWrapper matrix(args[2]); + Nan::TypedArrayContents matrix(info[2]); - vgColorMatrix((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - matrix.pointer()); + vgColorMatrix((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (*matrix)); - NanReturnUndefined(); + } NAN_METHOD(openvg::Convolve) { - NanScope(); + Nan::HandleScope scope; CheckArgs10(convolve, dstVGImage, Number, srcVGImage, Number, kernelWidth, Int32, kernelHeight, Int32, @@ -1528,24 +1419,22 @@ NAN_METHOD(openvg::Convolve) { kernel, Object, scale, Number, bias, Number, tilingMode, Uint32); - TypedArrayWrapper kernel(args[6]); + Nan::TypedArrayContents kernel(info[6]); - vgConvolve((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - kernel.pointer(), - (VGfloat) args[7]->NumberValue(), - (VGfloat) args[8]->NumberValue(), - static_cast(args[9]->Uint32Value())); - - NanReturnUndefined(); + vgConvolve((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (*kernel), + (VGfloat) info[7]->NumberValue(), + (VGfloat) info[8]->NumberValue(), + static_cast(info[9]->Uint32Value())); } NAN_METHOD(openvg::SeparableConvolve) { - NanScope(); + Nan::HandleScope scope; CheckArgs11(separableConvolve, dstVGImage, Number, srcVGImage, Number, kernelWidth, Int32, kernelHeight, Int32, @@ -1554,93 +1443,85 @@ NAN_METHOD(openvg::SeparableConvolve) { scale, Number, bias, Number, tilingMode, Uint32); - TypedArrayWrapper kernelX(args[6]); - TypedArrayWrapper kernelY(args[7]); - - vgSeparableConvolve((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGint) args[2]->Int32Value(), - (VGint) args[3]->Int32Value(), - (VGint) args[4]->Int32Value(), - (VGint) args[5]->Int32Value(), - kernelX.pointer(), - kernelY.pointer(), - (VGfloat) args[8]->NumberValue(), - (VGfloat) args[9]->NumberValue(), - static_cast(args[10]->Uint32Value())); + Nan::TypedArrayContents kernelX(info[6]); + Nan::TypedArrayContents kernelY(info[7]); - NanReturnUndefined(); + vgSeparableConvolve((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGint) info[2]->Int32Value(), + (VGint) info[3]->Int32Value(), + (VGint) info[4]->Int32Value(), + (VGint) info[5]->Int32Value(), + (*kernelX), + (*kernelY), + (VGfloat) info[8]->NumberValue(), + (VGfloat) info[9]->NumberValue(), + static_cast(info[10]->Uint32Value())); } NAN_METHOD(openvg::GaussianBlur) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(gaussianBlur, dstVGImage, Number, srcVGImage, Number, stdDeviationX, Number, stdDeviationY, Number, tilingMode, Uint32); - vgGaussianBlur((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - static_cast(args[4]->Uint32Value())); - - NanReturnUndefined(); + vgGaussianBlur((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + static_cast(info[4]->Uint32Value())); } NAN_METHOD(openvg::Lookup) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(lookup, VGImage, Number, dstVGImage, Number, srcVGImage, Number, redLUT, Object, greenLUT, Object, blueLUT, Object, alphaLUT, Object, outputLinear, Boolean, outputPremultiplied, Boolean); - TypedArrayWrapper redLUT(args[2]); - TypedArrayWrapper greenLUT(args[3]); - TypedArrayWrapper blueLUT(args[4]); - TypedArrayWrapper alphaLUT(args[5]); + Nan::TypedArrayContents redLUT(info[2]); + Nan::TypedArrayContents greenLUT(info[3]); + Nan::TypedArrayContents blueLUT(info[4]); + Nan::TypedArrayContents alphaLUT(info[5]); - vgLookup((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - redLUT.pointer(), - greenLUT.pointer(), - blueLUT.pointer(), - alphaLUT.pointer(), - (VGboolean) args[6]->BooleanValue(), - (VGboolean) args[7]->BooleanValue()); - - NanReturnUndefined(); + vgLookup((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (*redLUT), + (*greenLUT), + (*blueLUT), + (*alphaLUT), + (VGboolean) info[6]->BooleanValue(), + (VGboolean) info[7]->BooleanValue()); } NAN_METHOD(openvg::LookupSingle) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(lookupSingle, dstVGImage, Number, srcVGImage, Number, lookupTable, Object, sourceChannel, Uint32, outputLinear, Boolean, outputPremultiplied, Boolean); - TypedArrayWrapper lookupTable(args[2]); - - vgLookupSingle((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - lookupTable.pointer(), - static_cast(args[3]->Uint32Value()), - (VGboolean) args[4]->BooleanValue(), - (VGboolean) args[5]->BooleanValue()); + Nan::TypedArrayContents lookupTable(info[2]); - NanReturnUndefined(); + vgLookupSingle((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (*lookupTable), + static_cast(info[3]->Uint32Value()), + (VGboolean) info[4]->BooleanValue(), + (VGboolean) info[5]->BooleanValue()); } /* Hardware Queries */ NAN_METHOD(openvg::HardwareQuery) { - NanScope(); + Nan::HandleScope scope; CheckArgs2(hardwareQuery, key, Uint32, setting, Int32); - NanReturnValue(NanNew(vgHardwareQuery(static_cast(args[0]->Uint32Value()), - (VGint) args[1]->Int32Value()))); + info.GetReturnValue().Set(Nan::New(vgHardwareQuery(static_cast(info[0]->Uint32Value()), + (VGint) info[1]->Int32Value()))); } @@ -1648,11 +1529,11 @@ NAN_METHOD(openvg::HardwareQuery) { VG_API_CALL const VGubyte * VG_API_ENTRY vgGetString(VGStringID name) VG_API_EXIT; NAN_METHOD(openvg::GetString) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(getString, key, Uint32); - NanReturnValue(NanNew((char*) vgGetString(static_cast(args[0]->Uint32Value())))); + info.GetReturnValue().Set(Nan::New((char*) vgGetString(static_cast(info[0]->Uint32Value()))).ToLocalChecked()); } @@ -1660,159 +1541,159 @@ NAN_METHOD(openvg::GetString) { NAN_METHOD(openvg::vgu::Line) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(line, VGPath, Number, x0, Number, y0, Number, x1, Number, y1, Number); - NanReturnValue(NanNew(vguLine((VGPath) args[0]->Uint32Value(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue()))); + info.GetReturnValue().Set(Nan::New(vguLine((VGPath) info[0]->Uint32Value(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue()))); } NAN_METHOD(openvg::vgu::Polygon) { - NanScope(); + Nan::HandleScope scope; CheckArgs4(polygon, VGPath, Number, Float32Array, Object, count, Int32, closed, Boolean); - TypedArrayWrapper points(args[1]); + Nan::TypedArrayContents points(info[1]); - NanReturnValue(NanNew(vguPolygon((VGPath) args[0]->Uint32Value(), - points.pointer(), - (VGint) args[2]->Int32Value(), - (VGboolean) args[3]->BooleanValue()))); + info.GetReturnValue().Set(Nan::New(vguPolygon((VGPath) info[0]->Uint32Value(), + (*points), + (VGint) info[2]->Int32Value(), + (VGboolean) info[3]->BooleanValue()))); } NAN_METHOD(openvg::vgu::Rect) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(rect, VGPath, Number, x, Number, y, Number, width, Number, height, Number); - NanReturnValue(NanNew(vguRect((VGPath) args[0]->Uint32Value(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue()))); + info.GetReturnValue().Set(Nan::New(vguRect((VGPath) info[0]->Uint32Value(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue()))); } NAN_METHOD(openvg::vgu::RoundRect) { - NanScope(); + Nan::HandleScope scope; CheckArgs7(rect, VGPath, Number, x, Number, y, Number, width, Number, height, Number, arcWidth, Number, arcHeight, Number); - NanReturnValue(NanNew(vguRoundRect((VGPath) args[0]->Uint32Value(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue()))); + info.GetReturnValue().Set(Nan::New(vguRoundRect((VGPath) info[0]->Uint32Value(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue()))); } NAN_METHOD(openvg::vgu::Ellipse) { - NanScope(); + Nan::HandleScope scope; CheckArgs5(ellipse, VGPath, Number, x, Number, y, Number, width, Number, height, Number); - NanReturnValue(NanNew(vguEllipse((VGPath) args[0]->Uint32Value(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue()))); + info.GetReturnValue().Set(Nan::New(vguEllipse((VGPath) info[0]->Uint32Value(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue()))); } NAN_METHOD(openvg::vgu::Arc) { - NanScope(); + Nan::HandleScope scope; CheckArgs8(arc, VGPath, Number, x, Number, y, Number, width, Number, height, Number, startAngle, Number, angleExtent, Number, VGUArcType, Uint32); - NanReturnValue(NanNew(vguArc((VGPath) args[0]->Uint32Value(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - static_cast(args[7]->Uint32Value())))); + info.GetReturnValue().Set(Nan::New(vguArc((VGPath) info[0]->Uint32Value(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + static_cast(info[7]->Uint32Value())))); } NAN_METHOD(openvg::vgu::ComputeWarpQuadToSquare) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(computeWarpQuadToSquare, sx0, Number, sy0, Number, sx1, Number, sy1, Number, sx2, Number, sy2, Number, sx3, Number, sy3, Number, Float32Array, Object); - TypedArrayWrapper matrix(args[8]); + Nan::TypedArrayContents matrix(info[8]); - NanReturnValue(NanNew(vguComputeWarpQuadToSquare((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - matrix.pointer()))); + info.GetReturnValue().Set(Nan::New(vguComputeWarpQuadToSquare((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (*matrix)))); } NAN_METHOD(openvg::vgu::ComputeWarpSquareToQuad) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(computeWarpSquareToQuad, sx0, Number, sy0, Number, sx1, Number, sy1, Number, sx2, Number, sy2, Number, sx3, Number, sy3, Number, Float32Array, Object); - TypedArrayWrapper matrix(args[8]); + Nan::TypedArrayContents matrix(info[8]); - NanReturnValue(NanNew(vguComputeWarpSquareToQuad((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - matrix.pointer()))); + info.GetReturnValue().Set(Nan::New(vguComputeWarpSquareToQuad((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (*matrix)))); } NAN_METHOD(openvg::vgu::ComputeWarpQuadToQuad) { - NanScope(); + Nan::HandleScope scope; // No arg check -> Would be a 17 arg macro - TypedArrayWrapper matrix(args[16]); + Nan::TypedArrayContents matrix(info[16]); - NanReturnValue(NanNew(vguComputeWarpQuadToQuad((VGfloat) args[ 0]->NumberValue(), - (VGfloat) args[ 1]->NumberValue(), - (VGfloat) args[ 2]->NumberValue(), - (VGfloat) args[ 3]->NumberValue(), - (VGfloat) args[ 4]->NumberValue(), - (VGfloat) args[ 5]->NumberValue(), - (VGfloat) args[ 6]->NumberValue(), - (VGfloat) args[ 7]->NumberValue(), - (VGfloat) args[ 8]->NumberValue(), - (VGfloat) args[ 9]->NumberValue(), - (VGfloat) args[10]->NumberValue(), - (VGfloat) args[11]->NumberValue(), - (VGfloat) args[12]->NumberValue(), - (VGfloat) args[13]->NumberValue(), - (VGfloat) args[14]->NumberValue(), - (VGfloat) args[15]->NumberValue(), - matrix.pointer()))); + info.GetReturnValue().Set(Nan::New(vguComputeWarpQuadToQuad((VGfloat) info[ 0]->NumberValue(), + (VGfloat) info[ 1]->NumberValue(), + (VGfloat) info[ 2]->NumberValue(), + (VGfloat) info[ 3]->NumberValue(), + (VGfloat) info[ 4]->NumberValue(), + (VGfloat) info[ 5]->NumberValue(), + (VGfloat) info[ 6]->NumberValue(), + (VGfloat) info[ 7]->NumberValue(), + (VGfloat) info[ 8]->NumberValue(), + (VGfloat) info[ 9]->NumberValue(), + (VGfloat) info[10]->NumberValue(), + (VGfloat) info[11]->NumberValue(), + (VGfloat) info[12]->NumberValue(), + (VGfloat) info[13]->NumberValue(), + (VGfloat) info[14]->NumberValue(), + (VGfloat) info[15]->NumberValue(), + (*matrix)))); } @@ -1820,20 +1701,22 @@ NAN_METHOD(openvg::vgu::ComputeWarpQuadToQuad) { NAN_METHOD(openvg::ext::CreateEGLImageTargetKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(createEGLImageTargetKHR, VGeglImageKHR, Object); #ifdef VG_VGEXT_PROTOTYPES - VGeglImageKHR image = node::ObjectWrap::Unwrap(args[0]->ToObject()); - NanReturnValue(NanNew(vgCreateEGLImageTargetKHR(image))); +// TODO FIX THIS +// VGeglImageKHR *image = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); +// info.GetReturnValue().Set(Nan::New(vgCreateEGLImageTargetKHR(image))); + printf("openvg.cc:%d: CreateEGLImageTargetKHR needs fixing\n", __LINE__); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::IterativeAverageBlurKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs6(iterativeAverageBlurKHR, dstVGImage, Number, srcVGImage, Number, @@ -1841,18 +1724,17 @@ NAN_METHOD(openvg::ext::IterativeAverageBlurKHR) { tilingMode, Object); #ifdef VG_VGEXT_PROTOTYPES - vgIterativeAverageBlurKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGImage) args[4]->Uint32Value(), - static_cast((VGImage) args[5]->Uint32Value())); + vgIterativeAverageBlurKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGImage) info[4]->Uint32Value(), + static_cast((VGImage) info[5]->Uint32Value())); #endif - NanReturnUndefined(); } NAN_METHOD(openvg::ext::ParametricFilterKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(iterativeAverageBlurKHR, dstVGImage, Number, srcVGImage, Number, blurVGImage, Number, @@ -1860,22 +1742,20 @@ NAN_METHOD(openvg::ext::ParametricFilterKHR) { filterFlags, Number, highlightPaint, Number, shadowPaint, Number); #ifdef VG_VGEXT_PROTOTYPES - vgParametricFilterKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGImage) args[2]->Uint32Value(), - (VGfloat) args[3]->NumberValue(), - (VGfloat) args[4]->NumberValue(), - (VGfloat) args[5]->NumberValue(), - (VGbitfield) args[6]->Uint32Value(), - (VGPaint) args[7]->Uint32Value(), - (VGPaint) args[8]->Uint32Value()); + vgParametricFilterKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGImage) info[2]->Uint32Value(), + (VGfloat) info[3]->NumberValue(), + (VGfloat) info[4]->NumberValue(), + (VGfloat) info[5]->NumberValue(), + (VGbitfield) info[6]->Uint32Value(), + (VGPaint) info[7]->Uint32Value(), + (VGPaint) info[8]->Uint32Value()); #endif - - NanReturnUndefined(); } NAN_METHOD(openvg::ext::DropShadowKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs11(dropShadowKHR, dstVGImage, Number, srcVGImage, Number, @@ -1885,24 +1765,24 @@ NAN_METHOD(openvg::ext::DropShadowKHR) { shadowColorRGBA, Number); #ifdef VG_VGEXT_PROTOTYPES - NanReturnValue(NanNew(vguDropShadowKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGuint) args[4]->Uint32Value(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - (VGbitfield) args[8]->Uint32Value(), - (VGbitfield) args[9]->Uint32Value(), - (VGuint) args[10]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vguDropShadowKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGuint) info[4]->Uint32Value(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (VGbitfield) info[8]->Uint32Value(), + (VGbitfield) info[9]->Uint32Value(), + (VGuint) info[10]->Uint32Value()))); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::GlowKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs9(glowKHR, dstVGImage, Number, srcVGImage, Number, @@ -1912,22 +1792,22 @@ NAN_METHOD(openvg::ext::GlowKHR) { glowColorRGBA, Number); #ifdef VG_VGEXT_PROTOTYPES - NanReturnValue(NanNew(vguGlowKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGuint) args[4]->Uint32Value(), - (VGfloat) args[5]->NumberValue(), - (VGbitfield) args[6]->Uint32Value(), - (VGbitfield) args[7]->Uint32Value(), - (VGuint) args[8]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vguGlowKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGuint) info[4]->Uint32Value(), + (VGfloat) info[5]->NumberValue(), + (VGbitfield) info[6]->Uint32Value(), + (VGbitfield) info[7]->Uint32Value(), + (VGuint) info[8]->Uint32Value()))); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::BevelKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs12(bevelKHR, dstVGImage, Number, srcVGImage, Number, @@ -1937,25 +1817,25 @@ NAN_METHOD(openvg::ext::BevelKHR) { highlightColorRGBA, Number, shadowColorRGBA, Number); #ifdef VG_VGEXT_PROTOTYPES - NanReturnValue(NanNew(vguBevelKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGuint) args[4]->Uint32Value(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - (VGbitfield) args[8]->Uint32Value(), - (VGbitfield) args[9]->Uint32Value(), - (VGuint) args[10]->Uint32Value(), - (VGuint) args[11]->Uint32Value()))); + info.GetReturnValue().Set(Nan::New(vguBevelKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGuint) info[4]->Uint32Value(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (VGbitfield) info[8]->Uint32Value(), + (VGbitfield) info[9]->Uint32Value(), + (VGuint) info[10]->Uint32Value(), + (VGuint) info[11]->Uint32Value()))); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::GradientGlowKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs12(gradientGlowKHR, dstVGImage, Number, srcVGImage, Number, @@ -1965,27 +1845,27 @@ NAN_METHOD(openvg::ext::GradientGlowKHR) { stopsCount, Number, Float32Array, Object); #ifdef VG_VGEXT_PROTOTYPES - TypedArrayWrapper glowColorRampStops(args[11]); - - NanReturnValue(NanNew(vguGradientGlowKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGuint) args[4]->Uint32Value(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - (VGbitfield) args[8]->Uint32Value(), - (VGbitfield) args[9]->Uint32Value(), - (VGuint) args[10]->Uint32Value(), - glowColorRampStops.pointer()))); + Nan::TypedArrayContents glowColorRampStops(info[11]); + + info.GetReturnValue().Set(Nan::New(vguGradientGlowKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGuint) info[4]->Uint32Value(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (VGbitfield) info[8]->Uint32Value(), + (VGbitfield) info[9]->Uint32Value(), + (VGuint) info[10]->Uint32Value(), + (*glowColorRampStops)))); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::GradientBevelKHR) { - NanScope(); + Nan::HandleScope scope; CheckArgs12(gradientBevelKHR, dstVGImage, Number, srcVGImage, Number, @@ -1995,39 +1875,39 @@ NAN_METHOD(openvg::ext::GradientBevelKHR) { stopsCount, Number, Float32Array, Object); #ifdef VG_VGEXT_PROTOTYPES - TypedArrayWrapper bevelColorRampStops(args[11]); - - NanReturnValue(NanNew(vguGradientBevelKHR((VGImage) args[0]->Uint32Value(), - (VGImage) args[1]->Uint32Value(), - (VGfloat) args[2]->NumberValue(), - (VGfloat) args[3]->NumberValue(), - (VGuint) args[4]->Uint32Value(), - (VGfloat) args[5]->NumberValue(), - (VGfloat) args[6]->NumberValue(), - (VGfloat) args[7]->NumberValue(), - (VGbitfield) args[8]->Uint32Value(), - (VGbitfield) args[9]->Uint32Value(), - (VGuint) args[10]->Uint32Value(), - bevelColorRampStops.pointer()))); + Nan::TypedArrayContents bevelColorRampStops(info[11]); + + info.GetReturnValue().Set(Nan::New(vguGradientBevelKHR((VGImage) info[0]->Uint32Value(), + (VGImage) info[1]->Uint32Value(), + (VGfloat) info[2]->NumberValue(), + (VGfloat) info[3]->NumberValue(), + (VGuint) info[4]->Uint32Value(), + (VGfloat) info[5]->NumberValue(), + (VGfloat) info[6]->NumberValue(), + (VGfloat) info[7]->NumberValue(), + (VGbitfield) info[8]->Uint32Value(), + (VGbitfield) info[9]->Uint32Value(), + (VGuint) info[10]->Uint32Value(), + (*bevelColorRampStops)))); #else - NanReturnUndefined(); + #endif } NAN_METHOD(openvg::ext::ProjectiveMatrixNDS) { - NanScope(); + Nan::HandleScope scope; CheckArgs1(projectiveMatrixNDS, enable, Boolean); #ifdef VG_VGEXT_PROTOTYPES - vgProjectiveMatrixNDS((VGboolean) args[0]->BooleanValue()); + vgProjectiveMatrixNDS((VGboolean) info[0]->BooleanValue()); #endif - NanReturnUndefined(); + } NAN_METHOD(openvg::ext::TransformClipLineNDS) { - NanScope(); + Nan::HandleScope scope; CheckArgs8(gradientBevelKHR, Ain, Number, Bin, Number, Cin, Number, @@ -2035,20 +1915,20 @@ NAN_METHOD(openvg::ext::TransformClipLineNDS) { Float32Array, Object, Float32Array, Object, Float32Array, Object); #ifdef VG_VGEXT_PROTOTYPES - TypedArrayWrapper matrix(args[3]); - TypedArrayWrapper Aout(args[5]); - TypedArrayWrapper Bout(args[6]); - TypedArrayWrapper Cout(args[7]); - - NanReturnValue(NanNew(vguTransformClipLineNDS((VGfloat) args[0]->NumberValue(), - (VGfloat) args[1]->NumberValue(), - (VGfloat) args[2]->NumberValue(), - matrix.pointer(), - (VGboolean) args[4]->BooleanValue(), - Aout.pointer(), - Bout.pointer(), - Cout.pointer()))); + Nan::TypedArrayContents matrix(info[3]); + Nan::TypedArrayContents Aout(info[5]); + Nan::TypedArrayContents Bout(info[6]); + Nan::TypedArrayContents Cout(info[7]); + + info.GetReturnValue().Set(Nan::New(vguTransformClipLineNDS((VGfloat) info[0]->NumberValue(), + (VGfloat) info[1]->NumberValue(), + (VGfloat) info[2]->NumberValue(), + (*matrix), + (VGboolean) info[4]->BooleanValue(), + (*Aout), + (*Bout), + (*Cout)))); #else - NanReturnUndefined(); + #endif } From 05335fdba69e3b6d9e51b26e66fe8a63fb5289b9 Mon Sep 17 00:00:00 2001 From: ReneHollander Date: Wed, 21 Sep 2016 12:20:03 +0200 Subject: [PATCH 2/2] Fixed vgImageSubData --- src/openvg.cc | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/src/openvg.cc b/src/openvg.cc index dec4e0c..24d95b4 100755 --- a/src/openvg.cc +++ b/src/openvg.cc @@ -1116,23 +1116,8 @@ NAN_METHOD(openvg::ImageSubData) { dataFormat, Uint32, x, Int32, y, Int32, width, Int32, height, Int32); - Local data = info[1]->ToObject(); - void *dataPointer; - - Local nativeBuffer = data->Get(Nan::New("buffer").ToLocalChecked()); - if (!nativeBuffer->IsUndefined()) { - // Native array - //Handle dataBuffer = nativeBuffer->ToObject(); - //dataPointer = (void*) dataBuffer->GetIndexedPropertiesExternalArrayData(); - printf("openvg.cc:%d: Should not happen?\n", __LINE__); - exit(1); - } else { - // Node buffer - dataPointer = (void *) node::Buffer::Data(data); - } - vgImageSubData((VGImage) info[0]->Uint32Value(), - dataPointer, + node::Buffer::Data(info[1]), (VGint) info[2]->Int32Value(), static_cast(info[3]->Uint32Value()), (VGint) info[4]->Int32Value(),