node-gtk 0.10.0 → 0.12.0

package/src/function.cc

@@ -1,4 +1,3 @@
-
 #include <string.h>
 #include <girffi.h>
 
@@ -56,7 +55,7 @@ static void* AllocateArgument (GIBaseInfo *arg_info) {
 
     GIBaseInfo* base_info = g_type_info_get_interface (&arg_type);
     size_t size = Boxed::GetSize (base_info);
-    void* pointer = calloc(1, size);
+    void* pointer = g_malloc0(size);
 
     g_base_info_unref(base_info);
     return pointer;
@@ -165,14 +164,14 @@ bool FunctionInfo::Init() {
 
         call_parameters[i].direction = direction;
 
-        if (call_parameters[i].type == ParameterType::SKIP)
+        if (call_parameters[i].type == ParameterType::kSKIP)
             continue;
 
         // If there is an array length, this is an array
         int length_i = g_type_info_get_array_length (&type_info);
         if (tag == GI_TYPE_TAG_ARRAY && length_i >= 0) {
-            call_parameters[i].type        = ParameterType::ARRAY;
-            call_parameters[length_i].type = ParameterType::SKIP;
+            call_parameters[i].type        = ParameterType::kARRAY;
+            call_parameters[length_i].type = ParameterType::kSKIP;
 
             // If array length came before, we need to remove it from args count
 
@@ -190,9 +189,9 @@ bool FunctionInfo::Init() {
             if (interface_type == GI_INFO_TYPE_CALLBACK) {
                 if (IsDestroyNotify(interface_info)) {
                     /* Skip GDestroyNotify if they appear before the respective callback */
-                    call_parameters[i].type = ParameterType::SKIP;
+                    call_parameters[i].type = ParameterType::kSKIP;
                 } else {
-                    call_parameters[i].type = ParameterType::CALLBACK;
+                    call_parameters[i].type = ParameterType::kCALLBACK;
 
                     int destroy_i = g_arg_info_get_destroy(&arg_info);
                     int closure_i = g_arg_info_get_closure(&arg_info);
@@ -204,10 +203,10 @@ bool FunctionInfo::Init() {
                     }
 
                     if (destroy_i >= 0 && destroy_i < n_callable_args)
-                        call_parameters[destroy_i].type = ParameterType::SKIP;
+                        call_parameters[destroy_i].type = ParameterType::kSKIP;
 
                     if (closure_i >= 0 && closure_i < n_callable_args)
-                        call_parameters[closure_i].type = ParameterType::SKIP;
+                        call_parameters[closure_i].type = ParameterType::kSKIP;
 
                     if (destroy_i < i) {
                         if (IsDirectionIn(call_parameters[destroy_i].direction))
@@ -271,7 +270,7 @@ bool FunctionInfo::TypeCheck (const Nan::FunctionCallbackInfo<Value> &arguments)
     for (int in_arg = 0, i = 0; i < n_callable_args; i++) {
         Parameter &param = call_parameters[i];
 
-        if (param.type == ParameterType::SKIP)
+        if (param.type == ParameterType::kSKIP)
             continue;
 
         GIArgInfo arg_info;
@@ -325,7 +324,12 @@ Local<Value> FunctionCall (
      * and for error, if it can throw
      */
 
-    GIArgument total_arg_values[func->n_total_args];
+    #ifndef __linux__
+        GIArgument *total_arg_values = new GIArgument[func->n_total_args]();
+    #else
+        GIArgument total_arg_values[func->n_total_args];
+    #endif
+
     GIArgument *callable_arg_values;
     GError *error_stack = nullptr;
 
@@ -340,7 +344,6 @@ Local<Value> FunctionCall (
     if (func->can_throw)
         callable_arg_values[func->n_callable_args].v_pointer = error != NULL ? error : &error_stack;
 
-
     /*
      * Second, allocate OUT-arguments and fill IN-arguments
      */
@@ -348,7 +351,7 @@ Local<Value> FunctionCall (
     for (int in_arg = 0, i = 0; i < func->n_callable_args; i++) {
         Parameter& param = func->call_parameters[i];
 
-        if (param.type == ParameterType::SKIP)
+        if (param.type == ParameterType::kSKIP)
             continue;
 
         GIArgInfo arg_info;
@@ -357,7 +360,7 @@ Local<Value> FunctionCall (
         g_arg_info_load_type (&arg_info, &type_info);
         GIDirection direction = g_arg_info_get_direction (&arg_info);
 
-        if (param.type == ParameterType::ARRAY) {
+        if (param.type == ParameterType::kARRAY) {
             GIArgInfo  array_length_arg;
             GITypeInfo array_length_type;
 
@@ -383,7 +386,7 @@ Local<Value> FunctionCall (
                 callable_arg_values[length_i].v_pointer = &len_param.data;
             }
         }
-        else if (param.type == ParameterType::CALLBACK) {
+        else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback;
             ffi_closure *closure;
 
@@ -402,12 +405,12 @@ Local<Value> FunctionCall (
             int closure_i = g_arg_info_get_closure(&arg_info);
 
             if (destroy_i >= 0) {
-                g_assert (func->call_parameters[destroy_i].type == ParameterType::SKIP);
+                g_assert (func->call_parameters[destroy_i].type == ParameterType::kSKIP);
                 callable_arg_values[destroy_i].v_pointer = callback ? (void*) Callback::DestroyNotify : NULL;
             }
 
             if (closure_i >= 0) {
-                g_assert (func->call_parameters[closure_i].type == ParameterType::SKIP);
+                g_assert (func->call_parameters[closure_i].type == ParameterType::kSKIP);
                 callable_arg_values[closure_i].v_pointer = callback;
             }
 
@@ -426,7 +429,7 @@ Local<Value> FunctionCall (
         else /* (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) */ {
 
             // Callback GIArgument is filled above, for the rest...
-            if (param.type != ParameterType::CALLBACK) {
+            if (param.type != ParameterType::kCALLBACK) {
 
                 // FIXME(handle failure here)
                 FillArgument(&arg_info, &callable_arg_values[i], info[in_arg]);
@@ -448,16 +451,24 @@ Local<Value> FunctionCall (
      * Third, make the actual ffi_call
      */
 
-    void *ffi_args[func->n_total_args];
-    for (int i = 0; i < func->n_total_args; i++)
-        ffi_args[i] = &total_arg_values[i];
+    #ifndef __linux__
+        void **ffi_args = new void*[func->n_total_args]();
+    #else
+        void *ffi_args[func->n_total_args];
+    #endif
 
+    for (int i = 0; i < func->n_total_args; i++)
+        ffi_args[i] = (void *)&total_arg_values[i];
 
-    GIArgument return_value_stack;
+    GIArgument return_value_stack = {0};
 
     ffi_call (&func->invoker.cif, FFI_FN (func->invoker.native_address),
               use_return_value ? return_value : &return_value_stack, ffi_args);
 
+    #ifndef __linux__
+        delete[] ffi_args;
+    #endif
+
 
     /*
      * Fourth, convert the return value & OUT-arguments back to JS
@@ -507,13 +518,13 @@ Local<Value> FunctionCall (
         GIDirection direction = g_arg_info_get_direction (&arg_info);
         GITransfer transfer   = g_arg_info_get_ownership_transfer (&arg_info);
 
-        if (param.type == ParameterType::ARRAY) {
+        if (param.type == ParameterType::kARRAY) {
             if (direction == GI_DIRECTION_INOUT || direction == GI_DIRECTION_OUT)
                 FreeGIArgumentArray (&arg_type, (GIArgument*)arg_value.v_pointer, transfer, direction, param.length);
             else
                 FreeGIArgumentArray (&arg_type, &arg_value, transfer, direction, param.length);
         }
-        else if (param.type == ParameterType::CALLBACK) {
+        else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback = static_cast<Callback*>(func->call_parameters[i].data.v_pointer);
 
             g_assert(direction == GI_DIRECTION_IN);
@@ -530,6 +541,10 @@ Local<Value> FunctionCall (
         }
     }
 
+    #ifndef __linux__
+        delete[] total_arg_values;
+    #endif
+
     return jsReturnValue;
 }
 
@@ -595,7 +610,7 @@ Local<Value> FunctionInfo::GetReturnValue (
 
         if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
 
-            if (param.type == ParameterType::ARRAY) {
+            if (param.type == ParameterType::kARRAY) {
 
                 int length_i = g_type_info_get_array_length(&arg_type);
                 GIArgInfo length_arg;
@@ -614,7 +629,7 @@ Local<Value> FunctionInfo::GetReturnValue (
 
                 ADD_RETURN (result)
 
-            } else if (param.type == ParameterType::NORMAL) {
+            } else if (param.type == ParameterType::kNORMAL) {
 
                 if (IsPointerType(&arg_type) && g_arg_info_is_caller_allocates(&arg_info)) {
                     void *pointer = &arg_value.v_pointer;

package/src/function.h

@@ -16,7 +16,7 @@ using v8::String;
 namespace GNodeJS {
 
 enum ParameterType {
-    NORMAL, ARRAY, SKIP, CALLBACK
+    kNORMAL, kARRAY, kSKIP, kCALLBACK
 };
 
 struct Parameter {

package/src/gi.cc

@@ -1,4 +1,4 @@
-#include <gobject-introspection-1.0/girepository.h>
+#include <girepository.h>
 #include <node.h>
 #include <nan.h>
 
@@ -345,22 +345,22 @@ NAN_METHOD(RegisterVFunc) {
 void InitModule(Local<Object> exports, Local<Value> module, void *priv) {
     GNodeJS::AsyncCallEnvironment::Initialize();
 
-    NAN_EXPORT(exports, Bootstrap);
-    NAN_EXPORT(exports, GetModuleCache);
-    NAN_EXPORT(exports, GetBaseClass);
-    NAN_EXPORT(exports, GetTypeSize);
-    NAN_EXPORT(exports, GetConstantValue);
-    NAN_EXPORT(exports, MakeBoxedClass);
-    NAN_EXPORT(exports, MakeObjectClass);
-    NAN_EXPORT(exports, MakeFunction);
-    NAN_EXPORT(exports, StructFieldGetter);
-    NAN_EXPORT(exports, StructFieldSetter);
-    NAN_EXPORT(exports, ObjectPropertyGetter);
-    NAN_EXPORT(exports, ObjectPropertySetter);
-    NAN_EXPORT(exports, StartLoop);
-    NAN_EXPORT(exports, GetLoopStack);
-    NAN_EXPORT(exports, RegisterClass);
-    NAN_EXPORT(exports, RegisterVFunc);
+    Nan::Export(exports, "Bootstrap",            Bootstrap);
+    Nan::Export(exports, "GetModuleCache",       GetModuleCache);
+    Nan::Export(exports, "GetBaseClass",         GetBaseClass);
+    Nan::Export(exports, "GetTypeSize",          GetTypeSize);
+    Nan::Export(exports, "GetConstantValue",     GetConstantValue);
+    Nan::Export(exports, "MakeBoxedClass",       MakeBoxedClass);
+    Nan::Export(exports, "MakeObjectClass",      MakeObjectClass);
+    Nan::Export(exports, "MakeFunction",         MakeFunction);
+    Nan::Export(exports, "StructFieldGetter",    StructFieldGetter);
+    Nan::Export(exports, "StructFieldSetter",    StructFieldSetter);
+    Nan::Export(exports, "ObjectPropertyGetter", ObjectPropertyGetter);
+    Nan::Export(exports, "ObjectPropertySetter", ObjectPropertySetter);
+    Nan::Export(exports, "StartLoop",            StartLoop);
+    Nan::Export(exports, "GetLoopStack",         GetLoopStack);
+    Nan::Export(exports, "RegisterClass",        RegisterClass);
+    Nan::Export(exports, "RegisterVFunc",        RegisterVFunc);
 
     Nan::Set(exports, UTF8("System"), GNodeJS::System::GetModule());
     Nan::Set(exports, UTF8("Cairo"),  GNodeJS::Cairo::GetModule());

package/src/gobject.cc

@@ -87,7 +87,11 @@ static GObject* CreateGObjectFromObject(GType gtype, Local<Value> object) {
 
 out:
     g_strfreev ((gchar**) names);
+
+    for (int i = 0; i < n_properties; i++)
+        g_value_unset(&values[i]);
     g_free (values);
+
     g_type_class_unref (klass);
 
     return gobject;
@@ -346,7 +350,7 @@ NAN_METHOD(SignalConnect) {
     guint signalId;
     GQuark detail;
     GClosure *gclosure;
-    ulong handler_id;
+    gulong handler_id;
 
     const char *signalName = *Nan::Utf8String (TO_STRING (info[0]));
     if (!g_signal_parse_name(signalName, gtype, &signalId, &detail, FALSE)) {
@@ -386,7 +390,7 @@ NAN_METHOD(SignalDisconnect) {
     }
 
     gpointer instance = static_cast<gpointer>(gobject);
-    ulong handler_id = TO_LONG (info[0]);
+    gulong handler_id = TO_LONG (info[0]);
     g_signal_handler_disconnect (instance, handler_id);
 
     info.GetReturnValue().Set((double)handler_id);
@@ -443,7 +447,7 @@ NAN_METHOD(SignalEmit) {
     g_value_set_object(&args[0], gobject);
 
     failed = false;
-    for (uint i = 0; i < signal_query.n_params; i++) {
+    for (guint i = 0; i < signal_query.n_params; i++) {
         GValue *gvalue = &args[i + 1];
 
         g_value_init(gvalue, signal_query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE);
@@ -466,7 +470,7 @@ NAN_METHOD(SignalEmit) {
         }
     }
 
-    for (uint i = 0; i < argc; i++) {
+    for (guint i = 0; i < argc; i++) {
         g_value_unset(&args[i]);
     }
 }
@@ -486,7 +490,7 @@ NAN_METHOD(GObjectToString) {
     char *className = *Nan::Utf8String(self->GetConstructorName());
     void *address = self->GetAlignedPointerFromInternalField(0);
 
-    char *str = g_strdup_printf("[%s:%s %#zx]", typeName, className, (unsigned long)address);
+    char *str = g_strdup_printf("[%s:%s %#zx]", typeName, className, (size_t)address);
 
     info.GetReturnValue().Set(UTF8(str));
     g_free(str);

package/src/loop.cc

@@ -92,9 +92,14 @@ static GSourceFuncs uv_loop_source_funcs = {
 static GSource *loop_source_new (uv_loop_t *loop) {
     struct uv_loop_source *source = (struct uv_loop_source *) g_source_new (&uv_loop_source_funcs, sizeof (*source));
     source->loop = loop;
+#if OS_WINDOWS
+    // FIXME
+    // https://github.com/nodejs/node/issues/36015
+#else
     g_source_add_unix_fd (&source->source,
                           uv_backend_fd (loop),
                           (GIOCondition) (G_IO_IN | G_IO_OUT | G_IO_ERR));
+#endif
     return &source->source;
 }
 

package/src/modules/cairo/context.cc

@@ -1336,119 +1336,115 @@ NAN_METHOD(tagEnd) {
 }
 #endif
 
-#define SET_METHOD(tpl, name) Nan::SetPrototypeMethod(tpl, #name, name)
-
 static void AttachMethods(Local<FunctionTemplate> tpl) {
-  SET_METHOD(tpl, status);
-  SET_METHOD(tpl, save);
-  SET_METHOD(tpl, restore);
-  SET_METHOD(tpl, getTarget);
-  SET_METHOD(tpl, pushGroup);
-  SET_METHOD(tpl, pushGroupWithContent);
-  SET_METHOD(tpl, popGroup);
-  SET_METHOD(tpl, popGroupToSource);
-  SET_METHOD(tpl, getGroupTarget);
-  SET_METHOD(tpl, setSourceRgb);
-  SET_METHOD(tpl, setSourceRgba);
-  SET_METHOD(tpl, setSource);
-  SET_METHOD(tpl, setSourceSurface);
-  SET_METHOD(tpl, getSource);
-  SET_METHOD(tpl, setAntialias);
-  SET_METHOD(tpl, getAntialias);
-  SET_METHOD(tpl, getDashCount);
-  SET_METHOD(tpl, getDash);
-  SET_METHOD(tpl, setFillRule);
-  SET_METHOD(tpl, getFillRule);
-  SET_METHOD(tpl, setLineCap);
-  SET_METHOD(tpl, getLineCap);
-  SET_METHOD(tpl, setLineJoin);
-  SET_METHOD(tpl, getLineJoin);
-  SET_METHOD(tpl, setLineWidth);
-  SET_METHOD(tpl, getLineWidth);
-  SET_METHOD(tpl, setMiterLimit);
-  SET_METHOD(tpl, getMiterLimit);
-  SET_METHOD(tpl, setOperator);
-  SET_METHOD(tpl, getOperator);
-  SET_METHOD(tpl, setTolerance);
-  SET_METHOD(tpl, getTolerance);
-  SET_METHOD(tpl, clip);
-  SET_METHOD(tpl, clipPreserve);
-  SET_METHOD(tpl, clipExtents);
-  SET_METHOD(tpl, inClip);
-  SET_METHOD(tpl, resetClip);
-  SET_METHOD(tpl, copyClipRectangleList);
-  SET_METHOD(tpl, fill);
-  SET_METHOD(tpl, fillPreserve);
-  SET_METHOD(tpl, fillExtents);
-  SET_METHOD(tpl, inFill);
-  SET_METHOD(tpl, mask);
-  SET_METHOD(tpl, maskSurface);
-  SET_METHOD(tpl, paint);
-  SET_METHOD(tpl, paintWithAlpha);
-  SET_METHOD(tpl, stroke);
-  SET_METHOD(tpl, strokePreserve);
-  SET_METHOD(tpl, strokeExtents);
-  SET_METHOD(tpl, inStroke);
-  SET_METHOD(tpl, copyPage);
-  SET_METHOD(tpl, showPage);
-  SET_METHOD(tpl, getReferenceCount);
-  SET_METHOD(tpl, copyPath);
-  SET_METHOD(tpl, copyPathFlat);
-  SET_METHOD(tpl, appendPath);
-  SET_METHOD(tpl, hasCurrentPoint);
-  SET_METHOD(tpl, getCurrentPoint);
-  SET_METHOD(tpl, newPath);
-  SET_METHOD(tpl, newSubPath);
-  SET_METHOD(tpl, closePath);
-  SET_METHOD(tpl, arc);
-  SET_METHOD(tpl, arcNegative);
-  SET_METHOD(tpl, curveTo);
-  SET_METHOD(tpl, lineTo);
-  SET_METHOD(tpl, moveTo);
-  SET_METHOD(tpl, rectangle);
-  SET_METHOD(tpl, glyphPath);
-  SET_METHOD(tpl, textPath);
-  SET_METHOD(tpl, relCurveTo);
-  SET_METHOD(tpl, relLineTo);
-  SET_METHOD(tpl, relMoveTo);
-  SET_METHOD(tpl, pathExtents);
-  SET_METHOD(tpl, showText);
-  SET_METHOD(tpl, showGlyphs);
-  SET_METHOD(tpl, showTextGlyphs);
-  SET_METHOD(tpl, fontExtents);
-  SET_METHOD(tpl, textExtents);
-  SET_METHOD(tpl, glyphExtents);
-  SET_METHOD(tpl, selectFontFace);
-  SET_METHOD(tpl, setFontSize);
-  SET_METHOD(tpl, setFontMatrix);
-  SET_METHOD(tpl, getFontMatrix);
-  SET_METHOD(tpl, setFontOptions);
-  SET_METHOD(tpl, getFontOptions);
-  SET_METHOD(tpl, setFontFace);
-  SET_METHOD(tpl, getFontFace);
-  SET_METHOD(tpl, setScaledFont);
-  SET_METHOD(tpl, getScaledFont);
-  SET_METHOD(tpl, translate);
-  SET_METHOD(tpl, scale);
-  SET_METHOD(tpl, rotate);
-  SET_METHOD(tpl, transform);
-  SET_METHOD(tpl, setMatrix);
-  SET_METHOD(tpl, getMatrix);
-  SET_METHOD(tpl, identityMatrix);
-  SET_METHOD(tpl, userToDevice);
-  SET_METHOD(tpl, userToDeviceDistance);
-  SET_METHOD(tpl, deviceToUser);
-  SET_METHOD(tpl, deviceToUserDistance);
+  SET_PROTOTYPE_METHOD(tpl, status);
+  SET_PROTOTYPE_METHOD(tpl, save);
+  SET_PROTOTYPE_METHOD(tpl, restore);
+  SET_PROTOTYPE_METHOD(tpl, getTarget);
+  SET_PROTOTYPE_METHOD(tpl, pushGroup);
+  SET_PROTOTYPE_METHOD(tpl, pushGroupWithContent);
+  SET_PROTOTYPE_METHOD(tpl, popGroup);
+  SET_PROTOTYPE_METHOD(tpl, popGroupToSource);
+  SET_PROTOTYPE_METHOD(tpl, getGroupTarget);
+  SET_PROTOTYPE_METHOD(tpl, setSourceRgb);
+  SET_PROTOTYPE_METHOD(tpl, setSourceRgba);
+  SET_PROTOTYPE_METHOD(tpl, setSource);
+  SET_PROTOTYPE_METHOD(tpl, setSourceSurface);
+  SET_PROTOTYPE_METHOD(tpl, getSource);
+  SET_PROTOTYPE_METHOD(tpl, setAntialias);
+  SET_PROTOTYPE_METHOD(tpl, getAntialias);
+  SET_PROTOTYPE_METHOD(tpl, getDashCount);
+  SET_PROTOTYPE_METHOD(tpl, getDash);
+  SET_PROTOTYPE_METHOD(tpl, setFillRule);
+  SET_PROTOTYPE_METHOD(tpl, getFillRule);
+  SET_PROTOTYPE_METHOD(tpl, setLineCap);
+  SET_PROTOTYPE_METHOD(tpl, getLineCap);
+  SET_PROTOTYPE_METHOD(tpl, setLineJoin);
+  SET_PROTOTYPE_METHOD(tpl, getLineJoin);
+  SET_PROTOTYPE_METHOD(tpl, setLineWidth);
+  SET_PROTOTYPE_METHOD(tpl, getLineWidth);
+  SET_PROTOTYPE_METHOD(tpl, setMiterLimit);
+  SET_PROTOTYPE_METHOD(tpl, getMiterLimit);
+  SET_PROTOTYPE_METHOD(tpl, setOperator);
+  SET_PROTOTYPE_METHOD(tpl, getOperator);
+  SET_PROTOTYPE_METHOD(tpl, setTolerance);
+  SET_PROTOTYPE_METHOD(tpl, getTolerance);
+  SET_PROTOTYPE_METHOD(tpl, clip);
+  SET_PROTOTYPE_METHOD(tpl, clipPreserve);
+  SET_PROTOTYPE_METHOD(tpl, clipExtents);
+  SET_PROTOTYPE_METHOD(tpl, inClip);
+  SET_PROTOTYPE_METHOD(tpl, resetClip);
+  SET_PROTOTYPE_METHOD(tpl, copyClipRectangleList);
+  SET_PROTOTYPE_METHOD(tpl, fill);
+  SET_PROTOTYPE_METHOD(tpl, fillPreserve);
+  SET_PROTOTYPE_METHOD(tpl, fillExtents);
+  SET_PROTOTYPE_METHOD(tpl, inFill);
+  SET_PROTOTYPE_METHOD(tpl, mask);
+  SET_PROTOTYPE_METHOD(tpl, maskSurface);
+  SET_PROTOTYPE_METHOD(tpl, paint);
+  SET_PROTOTYPE_METHOD(tpl, paintWithAlpha);
+  SET_PROTOTYPE_METHOD(tpl, stroke);
+  SET_PROTOTYPE_METHOD(tpl, strokePreserve);
+  SET_PROTOTYPE_METHOD(tpl, strokeExtents);
+  SET_PROTOTYPE_METHOD(tpl, inStroke);
+  SET_PROTOTYPE_METHOD(tpl, copyPage);
+  SET_PROTOTYPE_METHOD(tpl, showPage);
+  SET_PROTOTYPE_METHOD(tpl, getReferenceCount);
+  SET_PROTOTYPE_METHOD(tpl, copyPath);
+  SET_PROTOTYPE_METHOD(tpl, copyPathFlat);
+  SET_PROTOTYPE_METHOD(tpl, appendPath);
+  SET_PROTOTYPE_METHOD(tpl, hasCurrentPoint);
+  SET_PROTOTYPE_METHOD(tpl, getCurrentPoint);
+  SET_PROTOTYPE_METHOD(tpl, newPath);
+  SET_PROTOTYPE_METHOD(tpl, newSubPath);
+  SET_PROTOTYPE_METHOD(tpl, closePath);
+  SET_PROTOTYPE_METHOD(tpl, arc);
+  SET_PROTOTYPE_METHOD(tpl, arcNegative);
+  SET_PROTOTYPE_METHOD(tpl, curveTo);
+  SET_PROTOTYPE_METHOD(tpl, lineTo);
+  SET_PROTOTYPE_METHOD(tpl, moveTo);
+  SET_PROTOTYPE_METHOD(tpl, rectangle);
+  SET_PROTOTYPE_METHOD(tpl, glyphPath);
+  SET_PROTOTYPE_METHOD(tpl, textPath);
+  SET_PROTOTYPE_METHOD(tpl, relCurveTo);
+  SET_PROTOTYPE_METHOD(tpl, relLineTo);
+  SET_PROTOTYPE_METHOD(tpl, relMoveTo);
+  SET_PROTOTYPE_METHOD(tpl, pathExtents);
+  SET_PROTOTYPE_METHOD(tpl, showText);
+  SET_PROTOTYPE_METHOD(tpl, showGlyphs);
+  SET_PROTOTYPE_METHOD(tpl, showTextGlyphs);
+  SET_PROTOTYPE_METHOD(tpl, fontExtents);
+  SET_PROTOTYPE_METHOD(tpl, textExtents);
+  SET_PROTOTYPE_METHOD(tpl, glyphExtents);
+  SET_PROTOTYPE_METHOD(tpl, selectFontFace);
+  SET_PROTOTYPE_METHOD(tpl, setFontSize);
+  SET_PROTOTYPE_METHOD(tpl, setFontMatrix);
+  SET_PROTOTYPE_METHOD(tpl, getFontMatrix);
+  SET_PROTOTYPE_METHOD(tpl, setFontOptions);
+  SET_PROTOTYPE_METHOD(tpl, getFontOptions);
+  SET_PROTOTYPE_METHOD(tpl, setFontFace);
+  SET_PROTOTYPE_METHOD(tpl, getFontFace);
+  SET_PROTOTYPE_METHOD(tpl, setScaledFont);
+  SET_PROTOTYPE_METHOD(tpl, getScaledFont);
+  SET_PROTOTYPE_METHOD(tpl, translate);
+  SET_PROTOTYPE_METHOD(tpl, scale);
+  SET_PROTOTYPE_METHOD(tpl, rotate);
+  SET_PROTOTYPE_METHOD(tpl, transform);
+  SET_PROTOTYPE_METHOD(tpl, setMatrix);
+  SET_PROTOTYPE_METHOD(tpl, getMatrix);
+  SET_PROTOTYPE_METHOD(tpl, identityMatrix);
+  SET_PROTOTYPE_METHOD(tpl, userToDevice);
+  SET_PROTOTYPE_METHOD(tpl, userToDeviceDistance);
+  SET_PROTOTYPE_METHOD(tpl, deviceToUser);
+  SET_PROTOTYPE_METHOD(tpl, deviceToUserDistance);
   #if CAIRO_VERSION_MAJOR >= 1 && CAIRO_VERSION_MINOR >= 16
-  SET_METHOD(tpl, tagBegin);
+  SET_PROTOTYPE_METHOD(tpl, tagBegin);
   #endif
   #if CAIRO_VERSION_MAJOR >= 1 && CAIRO_VERSION_MINOR >= 16
-  SET_METHOD(tpl, tagEnd);
+  SET_PROTOTYPE_METHOD(tpl, tagEnd);
   #endif
 }
 
-#undef SET_METHOD
-
 /* </ auto-generated */
 
 static void InstanceDestroyed(const Nan::WeakCallbackInfo<ContextInfo> &info);

package/src/modules/cairo/generator.js

@@ -521,8 +521,6 @@ function getReturn(fn, outArguments) {
 
 function getAttachMethods(name, functions) {
   return unindent(`
-    #define SET_METHOD(tpl, name) Nan::SetPrototypeMethod(tpl, #name, name)
-
     static void AttachMethods(Local<FunctionTemplate> tpl) {
         ${functions.map(fn =>
           (fn.attributes.version ? (() => {
@@ -533,12 +531,10 @@ function getAttachMethods(name, functions) {
               (micro ? 'CAIRO_VERSION_MICRO >= ' + micro : undefined),
             ].filter(Boolean).join(' && ') + '\n        '
           })() : '')
-          + `SET_METHOD(tpl, ${getJSName(fn.name)});`
+          + `SET_PROTOTYPE_METHOD(tpl, ${getJSName(fn.name)});`
           + (fn.attributes.version ? '\n        #endif' : '')
         ).join('\n        ')}
     }
-
-    #undef SET_METHOD
   `)
 }
 

package/src/type.cc

@@ -256,13 +256,13 @@ GITypeTag GetStorageType (GITypeInfo *type_info) {
     GITypeTag type_tag = g_type_info_get_tag (type_info);
 
     if (type_tag == GI_TYPE_TAG_INTERFACE) {
-        GIBaseInfo *interface = g_type_info_get_interface (type_info);
-        GIInfoType interface_type = g_base_info_get_type (interface);
+        GIBaseInfo *iface = g_type_info_get_interface (type_info);
+        GIInfoType iface_type = g_base_info_get_type (iface);
 
-        if (interface_type == GI_INFO_TYPE_ENUM || interface_type == GI_INFO_TYPE_FLAGS)
-            type_tag = g_enum_info_get_storage_type ((GIEnumInfo *)interface);
+        if (iface_type == GI_INFO_TYPE_ENUM || iface_type == GI_INFO_TYPE_FLAGS)
+            type_tag = g_enum_info_get_storage_type ((GIEnumInfo *)iface);
 
-        g_base_info_unref (interface);
+        g_base_info_unref (iface);
     }
 
     return type_tag;

package/src/util.h

@@ -55,9 +55,7 @@ inline void SetProtoAccessor(
             setter,
             v8::Local<v8::Value>(),
             v8::DEFAULT,
-            v8::None,
-            v8::AccessorSignature::New(v8::Isolate::GetCurrent(), ctor)
-            );
+            v8::None);
 }
 
 namespace Util