node-gtk 2.2.0 → 4.0.0

package/src/fundamental.cc

@@ -0,0 +1,451 @@
+/*
+ * fundamental.cc
+ *
+ * See fundamental.h. Wraps fundamental (non-GObject) ref-counted types such as
+ * GskRenderNode. The wrapper owns exactly one reference (taken via the type's
+ * introspected ref function, or adopted from a transfer-full return) and drops
+ * it on garbage collection via the unref function. Unlike GObject wrappers this
+ * uses no toggle-ref / qdata / weak-ref machinery — a fundamental type is not a
+ * GObject and those calls would fail their G_IS_OBJECT assertions (#468).
+ */
+
+#include <girepository.h>
+#include <glib.h>
+
+#include "fundamental.h"
+#include "gi.h"
+#include "macros.h"
+#include "util.h"
+#include "value.h"
+
+using v8::External;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Object;
+using Nan::New;
+using Nan::Persistent;
+using Nan::WeakCallbackType;
+
+namespace GNodeJS {
+
+/* Per-instance bookkeeping so the GC weak callback can drop our reference. */
+struct FundamentalInstance {
+    void *data;
+    GIObjectInfoUnrefFunction unref;
+    Persistent<Object> *persistent;
+};
+
+bool IsFundamentalObjectInfo (GIObjectInfo *info) {
+    if (g_base_info_get_type (info) != GI_INFO_TYPE_OBJECT)
+        return false;
+    if (!g_object_info_get_fundamental (info))
+        return false;
+
+    /* GParamSpec is also a fundamental (non-GObject) type, but it has its own
+     * dedicated wrapper (param_spec.cc) that predates this one and is used by
+     * the value.cc / V8ToGIArgumentInterface param paths; keep it on that
+     * path rather than diverting it here. */
+    GType gtype = g_registered_type_info_get_g_type (info);
+    if (g_type_is_a (gtype, G_TYPE_PARAM))
+        return false;
+
+    return true;
+}
+
+/*
+ * The ref/unref functions are declared on the root fundamental type (e.g.
+ * GskRenderNode) and are not repeated on derived infos (GskColorNode), so walk
+ * up the parent chain until we find them.
+ */
+static void GetRefFunctions (GIObjectInfo *info,
+                             GIObjectInfoRefFunction *refOut,
+                             GIObjectInfoUnrefFunction *unrefOut) {
+    *refOut = NULL;
+    *unrefOut = NULL;
+
+    GIObjectInfo *current = g_base_info_ref (info);
+    while (current != NULL) {
+        auto ref = g_object_info_get_ref_function_pointer (current);
+        auto unref = g_object_info_get_unref_function_pointer (current);
+        if (ref != NULL || unref != NULL) {
+            *refOut = ref;
+            *unrefOut = unref;
+            break;
+        }
+        GIObjectInfo *parent = g_object_info_get_parent (current);
+        g_base_info_unref (current);
+        current = parent;
+    }
+
+    if (current != NULL)
+        g_base_info_unref (current);
+}
+
+void RefFundamentalForTransferFullIn (GITypeInfo *type_info, GIArgument *arg) {
+    if (arg->v_pointer == NULL)
+        return;
+
+    if (g_type_info_get_tag (type_info) != GI_TYPE_TAG_INTERFACE)
+        return;
+
+    GIBaseInfo *iface = g_type_info_get_interface (type_info);
+
+    /* The callee takes ownership of one reference (transfer-full). The JS
+     * wrapper keeps its own single reference and drops it on GC, so without an
+     * extra reference here the object would be finalized out from under the
+     * callee. This is the fundamental counterpart of RefObjectForTransferFullIn
+     * (GObjects, #439) and CopyBoxedForTransferFullIn (boxed, #409). */
+    if (IsFundamentalObjectInfo (iface)) {
+        GIObjectInfoRefFunction ref;
+        GIObjectInfoUnrefFunction unref;
+        GetRefFunctions (iface, &ref, &unref);
+        if (ref != NULL)
+            ref (arg->v_pointer);
+    }
+
+    g_base_info_unref (iface);
+}
+
+static void FundamentalDestroyed (const Nan::WeakCallbackInfo<FundamentalInstance> &info) {
+    FundamentalInstance *self = info.GetParameter ();
+
+    if (self->data != NULL && self->unref != NULL)
+        self->unref (self->data);
+
+    /* Nan's kParameter weak callback already Reset()s the handle in its first
+     * pass (nan_weak.h); calling Reset() again here would double-destroy the
+     * global handle (V8 "IsInUse" fatal). Just free our bookkeeping, matching
+     * BoxedDestroyed. */
+    delete self->persistent;
+    delete self;
+}
+
+static void FundamentalConstructor (const Nan::FunctionCallbackInfo<Value> &info) {
+    if (!info.IsConstructCall ()) {
+        Nan::ThrowTypeError ("Not a construct call");
+        return;
+    }
+
+    Local<Object> self = info.This ();
+    GIObjectInfo *gi_info = (GIObjectInfo *) External::Cast (*info.Data ())->Value ();
+    GType gtype = g_registered_type_info_get_g_type (gi_info);
+
+    if (!info[0]->IsExternal ()) {
+        /* Fundamental types can't be created with g_object_new; they are
+         * obtained from function returns or their static constructors
+         * (e.g. `Gsk.ColorNode.new(...)`). */
+        char *message = g_strdup_printf (
+            "Cannot construct fundamental type %s directly; use its static constructor (e.g. .new())",
+            g_type_name (gtype));
+        Nan::ThrowError (message);
+        g_free (message);
+        return;
+    }
+
+    void *ptr = External::Cast (*info[0])->Value ();
+    auto ownership = (ResourceOwnership) Nan::To<int32_t> (info[1]).ToChecked ();
+
+    GIObjectInfoRefFunction ref;
+    GIObjectInfoUnrefFunction unref;
+    GetRefFunctions (gi_info, &ref, &unref);
+
+    /* Own exactly one reference for the lifetime of the wrapper. A
+     * transfer-full return (kTransfer) already handed us one; otherwise add our
+     * own so the instance stays alive while JS holds the wrapper. */
+    if (ownership != kTransfer && ref != NULL)
+        ptr = ref (ptr);
+
+    FundamentalInstance *instance = new FundamentalInstance ();
+    instance->data = ptr;
+    instance->unref = unref;
+    instance->persistent = new Persistent<Object> (self);
+    instance->persistent->SetWeak (instance, FundamentalDestroyed, WeakCallbackType::kParameter);
+
+    Nan::SetInternalFieldPointer (self, 0, ptr);
+    SET_OBJECT_GTYPE (self, gtype);
+}
+
+static void FundamentalToString (const Nan::FunctionCallbackInfo<Value> &info) {
+    Local<Object> self = info.This ();
+
+    if (!ValueHasInternalField (self)) {
+        Nan::ThrowTypeError ("Object is not a fundamental type");
+        return;
+    }
+
+    GType gtype = GET_OBJECT_GTYPE (self);
+    void *address = Nan::GetInternalFieldPointer (self, 0);
+    char *str = g_strdup_printf ("[%s %#zx]", g_type_name (gtype), (size_t) address);
+    info.GetReturnValue ().Set (UTF8 (str));
+    g_free (str);
+}
+
+static Local<FunctionTemplate> GetFundamentalBaseTemplate () {
+    static Persistent<FunctionTemplate> baseTemplate;
+
+    if (baseTemplate.IsEmpty ()) {
+        auto tpl = New<FunctionTemplate> ();
+        tpl->SetClassName (UTF8 ("FundamentalBaseClass"));
+        Nan::SetPrototypeMethod (tpl, "toString", FundamentalToString);
+        baseTemplate.Reset (tpl);
+    }
+
+    return New (baseTemplate);
+}
+
+static void FundamentalClassDestroyed (const Nan::WeakCallbackInfo<GIBaseInfo> &info) {
+    GIBaseInfo *gi_info = info.GetParameter ();
+    GType gtype = g_registered_type_info_get_g_type (gi_info);
+
+    auto *persistentTpl = (Persistent<FunctionTemplate> *) g_type_get_qdata (gtype, GNodeJS::template_quark ());
+    auto *persistentFn  = (Persistent<Function> *)         g_type_get_qdata (gtype, GNodeJS::function_quark ());
+    delete persistentTpl;
+    delete persistentFn;
+
+    g_type_set_qdata (gtype, GNodeJS::template_quark (), NULL);
+    g_type_set_qdata (gtype, GNodeJS::function_quark (), NULL);
+
+    g_base_info_unref (gi_info);
+}
+
+static Local<FunctionTemplate> GetFundamentalTemplate (GIObjectInfo *info, GType gtype) {
+    void *data = g_type_get_qdata (gtype, GNodeJS::template_quark ());
+
+    if (data) {
+        auto *persistent = (Persistent<FunctionTemplate> *) data;
+        return New<FunctionTemplate> (*persistent);
+    }
+
+    /* The External holds a borrowed pointer; the owned ref is taken by the
+     * SetWeak below and released in FundamentalClassDestroyed. `info` stays
+     * alive for the template's whole lifetime, so the borrow is safe (mirrors
+     * boxed.cc's GetBoxedTemplate). */
+    auto tpl = New<FunctionTemplate> (FundamentalConstructor, New<External> (info));
+    tpl->SetClassName (UTF8 (g_type_name (gtype)));
+    tpl->InstanceTemplate ()->SetInternalFieldCount (1);
+    Nan::SetPrototypeTemplate (
+        tpl, "__gtype__", v8::BigInt::NewFromUnsigned (Isolate::GetCurrent (), gtype));
+
+    GType parent_type = g_type_parent (gtype);
+    if (parent_type == G_TYPE_INVALID) {
+        tpl->Inherit (GetFundamentalBaseTemplate ());
+    } else {
+        GIObjectInfo *parent_info = (GIObjectInfo *) g_irepository_find_by_gtype (NULL, parent_type);
+        if (parent_info != NULL) {
+            tpl->Inherit (GetFundamentalTemplate (parent_info, parent_type));
+            g_base_info_unref (parent_info);
+        } else {
+            tpl->Inherit (GetFundamentalBaseTemplate ());
+        }
+    }
+
+    auto *persistentTpl = new Persistent<FunctionTemplate> (tpl);
+    auto *persistentFn  = new Persistent<Function> (Nan::GetFunction (tpl).ToLocalChecked ());
+    persistentTpl->SetWeak (
+        g_base_info_ref (info), FundamentalClassDestroyed, WeakCallbackType::kParameter);
+
+    g_type_set_qdata (gtype, GNodeJS::template_quark (), persistentTpl);
+    g_type_set_qdata (gtype, GNodeJS::function_quark (), persistentFn);
+
+    return tpl;
+}
+
+MaybeLocal<Function> MakeFundamentalClass (GIObjectInfo *info) {
+    GType gtype = g_registered_type_info_get_g_type (info);
+
+    if (gtype == G_TYPE_NONE || gtype == G_TYPE_INVALID)
+        return MaybeLocal<Function> ();
+
+    void *data = g_type_get_qdata (gtype, GNodeJS::function_quark ());
+    if (data == NULL) {
+        GetFundamentalTemplate (info, gtype);
+        data = g_type_get_qdata (gtype, GNodeJS::function_quark ());
+    }
+
+    auto *persistent = (Persistent<Function> *) data;
+    return New<Function> (*persistent);
+}
+
+Local<Value> WrapperFromFundamental (GIObjectInfo *info, void *ptr, ResourceOwnership ownership) {
+    if (ptr == NULL)
+        return Nan::Null ();
+
+    /* Resolve the *actual* runtime type of the instance (e.g. GskColorNode)
+     * rather than the static return type (GskRenderNode), mirroring how
+     * WrapperFromGObject uses G_OBJECT_TYPE. Introspected fundamental types are
+     * classed GTypeInstances, so G_TYPE_FROM_INSTANCE is valid here. */
+    GIObjectInfo *resolved = NULL;
+    GType instance_gtype = G_TYPE_FROM_INSTANCE (ptr);
+    if (instance_gtype != G_TYPE_INVALID) {
+        GIBaseInfo *found = g_irepository_find_by_gtype (NULL, instance_gtype);
+        if (found != NULL) {
+            if (IsFundamentalObjectInfo (found))
+                resolved = found;
+            else
+                g_base_info_unref (found);
+        }
+    }
+
+    auto maybeConstructor = MakeFundamentalClass (resolved != NULL ? resolved : info);
+
+    if (resolved != NULL)
+        g_base_info_unref (resolved);
+
+    if (maybeConstructor.IsEmpty ())
+        return Nan::Null ();
+
+    Local<Value> args[] = {
+        New<External> (ptr),
+        New<v8::Int32> ((int32_t) ownership),
+    };
+
+    auto instance = Nan::NewInstance (maybeConstructor.ToLocalChecked (), 2, args);
+    if (instance.IsEmpty ())
+        return Nan::Null ();
+
+    return instance.ToLocalChecked ();
+}
+
+
+/*
+ * GVariant
+ *
+ * GVariant is a fundamental ref-counted type, but GI classes it as a
+ * GIStructInfo (g_type == G_TYPE_VARIANT), so the object-info machinery above
+ * (G_TYPE_FROM_INSTANCE, introspected ref/unref functions) does not apply. It
+ * uses the shared FundamentalInstance lifetime with hardcoded g_variant_ref/
+ * unref and floating-reference handling (g_variant_ref_sink / take_ref).
+ */
+
+/* Matches GIObjectInfoUnrefFunction's signature so FundamentalInstance can call
+ * it uniformly; avoids a function-pointer cast. */
+static void VariantUnref (void *data) {
+    g_variant_unref ((GVariant *) data);
+}
+
+bool IsVariantInfo (GIBaseInfo *info) {
+    GIInfoType type = g_base_info_get_type (info);
+    if (type != GI_INFO_TYPE_STRUCT
+            && type != GI_INFO_TYPE_BOXED
+            && type != GI_INFO_TYPE_UNION
+            && type != GI_INFO_TYPE_OBJECT)
+        return false;
+    return g_registered_type_info_get_g_type (info) == G_TYPE_VARIANT;
+}
+
+bool IsVariantTypeInfo (GITypeInfo *type_info) {
+    if (g_type_info_get_tag (type_info) != GI_TYPE_TAG_INTERFACE)
+        return false;
+    GIBaseInfo *iface = g_type_info_get_interface (type_info);
+    bool result = IsVariantInfo (iface);
+    g_base_info_unref (iface);
+    return result;
+}
+
+static void VariantConstructor (const Nan::FunctionCallbackInfo<Value> &info) {
+    if (!info.IsConstructCall ()) {
+        Nan::ThrowTypeError ("Not a construct call");
+        return;
+    }
+
+    Local<Object> self = info.This ();
+
+    if (!info[0]->IsExternal ()) {
+        /* Like the object fundamentals, variants are obtained from function
+         * returns or their static constructors (e.g. GLib.Variant.newString),
+         * not built with `new`. */
+        Nan::ThrowError (
+            "Cannot construct GLib.Variant directly; use a static constructor (e.g. GLib.Variant.newString())");
+        return;
+    }
+
+    void *ptr = External::Cast (*info[0])->Value ();
+    auto ownership = (ResourceOwnership) Nan::To<int32_t> (info[1]).ToChecked ();
+
+    /* Own exactly one full (non-floating) reference for the wrapper's lifetime.
+     * A transfer-full return already handed us a reference to adopt (take_ref
+     * sinks it if it was floating); otherwise add our own (ref_sink sinks a
+     * fresh floating variant, or refs a shared one). */
+    if (ownership == kTransfer)
+        ptr = g_variant_take_ref ((GVariant *) ptr);
+    else
+        ptr = g_variant_ref_sink ((GVariant *) ptr);
+
+    FundamentalInstance *instance = new FundamentalInstance ();
+    instance->data = ptr;
+    instance->unref = VariantUnref;
+    instance->persistent = new Persistent<Object> (self);
+    instance->persistent->SetWeak (instance, FundamentalDestroyed, WeakCallbackType::kParameter);
+
+    Nan::SetInternalFieldPointer (self, 0, ptr);
+    SET_OBJECT_GTYPE (self, G_TYPE_VARIANT);
+}
+
+static Local<FunctionTemplate> GetVariantTemplate () {
+    GType gtype = G_TYPE_VARIANT;
+    void *data = g_type_get_qdata (gtype, GNodeJS::template_quark ());
+
+    if (data) {
+        auto *persistent = (Persistent<FunctionTemplate> *) data;
+        return New<FunctionTemplate> (*persistent);
+    }
+
+    auto tpl = New<FunctionTemplate> (VariantConstructor);
+    tpl->SetClassName (UTF8 (g_type_name (gtype)));
+    tpl->InstanceTemplate ()->SetInternalFieldCount (1);
+    Nan::SetPrototypeTemplate (
+        tpl, "__gtype__", v8::BigInt::NewFromUnsigned (Isolate::GetCurrent (), gtype));
+    tpl->Inherit (GetFundamentalBaseTemplate ());
+
+    /* G_TYPE_VARIANT is a static built-in fundamental that never unloads, so
+     * (unlike the per-namespace fundamental object templates) there is no
+     * class-destroyed weak callback to tear the cache down. */
+    auto *persistentTpl = new Persistent<FunctionTemplate> (tpl);
+    auto *persistentFn  = new Persistent<Function> (Nan::GetFunction (tpl).ToLocalChecked ());
+    g_type_set_qdata (gtype, GNodeJS::template_quark (), persistentTpl);
+    g_type_set_qdata (gtype, GNodeJS::function_quark (), persistentFn);
+
+    return tpl;
+}
+
+Local<Function> MakeVariantClass (GIBaseInfo *info) {
+    void *data = g_type_get_qdata (G_TYPE_VARIANT, GNodeJS::function_quark ());
+    if (data == NULL) {
+        GetVariantTemplate ();
+        data = g_type_get_qdata (G_TYPE_VARIANT, GNodeJS::function_quark ());
+    }
+
+    auto *persistent = (Persistent<Function> *) data;
+    return New<Function> (*persistent);
+}
+
+Local<Value> WrapperFromVariant (void *ptr, ResourceOwnership ownership) {
+    if (ptr == NULL)
+        return Nan::Null ();
+
+    Local<Function> constructor = MakeVariantClass (NULL);
+
+    Local<Value> args[] = {
+        New<External> (ptr),
+        New<v8::Int32> ((int32_t) ownership),
+    };
+
+    auto instance = Nan::NewInstance (constructor, 2, args);
+    if (instance.IsEmpty ())
+        return Nan::Null ();
+
+    return instance.ToLocalChecked ();
+}
+
+void RefVariantForTransferFullIn (GITypeInfo *type_info, GIArgument *arg) {
+    if (arg->v_pointer == NULL)
+        return;
+
+    /* The callee takes ownership of one reference; keep our own so the JS
+     * wrapper isn't unref'd out from under it (counterpart of the boxed/object
+     * transfer-full helpers). */
+    if (IsVariantTypeInfo (type_info))
+        arg->v_pointer = g_variant_ref ((GVariant *) arg->v_pointer);
+}
+
+};

package/src/fundamental.h

@@ -0,0 +1,71 @@
+/*
+ * fundamental.h
+ *
+ * Wrapping of GLib *fundamental* ref-counted types that are not GObjects —
+ * e.g. GskRenderNode, which has its own gsk_render_node_ref()/unref() instead
+ * of the GObject machinery. GObject-Introspection reports these as
+ * GI_INFO_TYPE_OBJECT (a GIObjectInfo) with g_object_info_get_fundamental()
+ * == TRUE, but running the GObject wrapper path over them fires G_IS_OBJECT
+ * assertions (#468). They get their own thin wrapper here.
+ */
+
+#pragma once
+
+#include <node.h>
+#include <nan.h>
+#include <girepository.h>
+#include <glib-object.h>
+
+#include "value.h"
+
+using v8::Function;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Value;
+
+namespace GNodeJS {
+
+/* True when the GIObjectInfo describes a fundamental (non-GObject) type. */
+bool IsFundamentalObjectInfo (GIObjectInfo *info);
+
+/* Build (or fetch the cached) constructor for a fundamental type. Mirrors
+ * MakeClass()/MakeBoxedClass(); JS attaches the introspected methods to it. */
+MaybeLocal<Function> MakeFundamentalClass (GIObjectInfo *info);
+
+/* Wrap a fundamental instance for return to JS, taking a reference according
+ * to `ownership` (kTransfer: adopt the incoming ref; otherwise add our own). */
+Local<Value> WrapperFromFundamental (GIObjectInfo *info, void *ptr, ResourceOwnership ownership);
+
+/* Add the reference a transfer-full IN argument's callee will own, so the
+ * instance isn't finalized out from under it when the JS wrapper is GC'd.
+ * Fundamental counterpart of RefObjectForTransferFullIn / CopyBoxedForTransferFullIn. */
+void RefFundamentalForTransferFullIn (GITypeInfo *type_info, GIArgument *arg);
+
+
+/*
+ * GVariant is also a fundamental (non-GObject) ref-counted type, but GObject-
+ * Introspection reports it as a GI_INFO_TYPE_STRUCT (a GIStructInfo) with
+ * g_type == G_TYPE_VARIANT, not as a fundamental GIObjectInfo. It is refcounted
+ * with g_variant_ref/unref (and has floating references), so it gets the same
+ * single-owned-reference wrapper as the object fundamentals above rather than
+ * the boxed copy/free path. Its JS class is still built from the struct info
+ * (so its introspected methods attach), just with this ref/unref lifetime.
+ */
+
+/* True when `info` is a registered type whose g_type is G_TYPE_VARIANT. */
+bool IsVariantInfo (GIBaseInfo *info);
+
+/* True when `type_info` is an interface referring to G_TYPE_VARIANT. */
+bool IsVariantTypeInfo (GITypeInfo *type_info);
+
+/* Build (or fetch the cached) constructor for GLib.Variant. */
+Local<Function> MakeVariantClass (GIBaseInfo *info);
+
+/* Wrap a GVariant for return to JS, taking a reference according to `ownership`
+ * (kTransfer: adopt the incoming reference; otherwise add our own). */
+Local<Value> WrapperFromVariant (void *ptr, ResourceOwnership ownership);
+
+/* Transfer-full IN counterpart for GVariant (adds the callee's reference). */
+void RefVariantForTransferFullIn (GITypeInfo *type_info, GIArgument *arg);
+
+};

package/src/gi.cc

@@ -5,6 +5,7 @@
 #include "async_call_environment.h"
 #include "boxed.h"
 #include "debug.h"
+#include "fundamental.h"
 #include "function.h"
 #include "gi.h"
 #include "gobject.h"
@@ -170,7 +171,11 @@ NAN_METHOD(MakeFunction) {
 
 NAN_METHOD(MakeObjectClass) {
     BaseInfo gi_info(info[0]);
-    auto klass = GNodeJS::MakeClass(*gi_info);
+    // Fundamental (non-GObject) types such as GskRenderNode need their own
+    // ref/unref-based wrapper rather than the GObject machinery (#468).
+    auto klass = GNodeJS::IsFundamentalObjectInfo(*gi_info)
+        ? GNodeJS::MakeFundamentalClass(*gi_info)
+        : GNodeJS::MakeClass(*gi_info);
     if (!klass.IsEmpty())
         info.GetReturnValue().Set(klass.ToLocalChecked());
 }
@@ -405,6 +410,14 @@ NAN_METHOD(GetModuleCache) {
     info.GetReturnValue().Set(Nan::New<Object>(GNodeJS::moduleCache));
 }
 
+NAN_METHOD(SetLazyClassRegister) {
+    GNodeJS::ObjectClass::SetLazyClassRegister(info);
+}
+
+NAN_METHOD(SetInterfaceMethodsApplier) {
+    GNodeJS::SetInterfaceMethodsApplier(info);
+}
+
 NAN_METHOD(RegisterClass) {
     GNodeJS::ObjectClass::RegisterClass(info);
 }
@@ -413,6 +426,10 @@ NAN_METHOD(RegisterVFunc) {
     GNodeJS::ObjectClass::RegisterVFunc(info);
 }
 
+NAN_METHOD(CallVFunc) {
+    GNodeJS::ObjectClass::CallVFunc(info);
+}
+
 void InitModule(Local<Object> exports, Local<Value> module, void *priv) {
     GNodeJS::AsyncCallEnvironment::Initialize();
 
@@ -431,8 +448,11 @@ void InitModule(Local<Object> exports, Local<Value> module, void *priv) {
     Nan::Export(exports, "StartLoop",            StartLoop);
     Nan::Export(exports, "IsRunningMicrotasks",  IsRunningMicrotasks);
     Nan::Export(exports, "GetLoopStack",         GetLoopStack);
+    Nan::Export(exports, "SetLazyClassRegister", SetLazyClassRegister);
+    Nan::Export(exports, "SetInterfaceMethodsApplier", SetInterfaceMethodsApplier);
     Nan::Export(exports, "RegisterClass",        RegisterClass);
     Nan::Export(exports, "RegisterVFunc",        RegisterVFunc);
+    Nan::Export(exports, "CallVFunc",            CallVFunc);
 
     Nan::Set(exports, UTF8("System"), GNodeJS::System::GetModule());
     Nan::Set(exports, UTF8("Cairo"),  GNodeJS::Cairo::GetModule());