node-gtk 2.2.0 → 4.0.0

package/src/gobject.cc

@@ -1,6 +1,8 @@
 
 #include <string.h>
 
+#include <vector>
+
 #include "boxed.h"
 #include "callback.h"
 #include "closure.h"
@@ -33,6 +35,16 @@ namespace GNodeJS {
 // Our base template for all GObjects
 static Nan::Persistent<FunctionTemplate> baseTemplate;
 
+// JS callback (registerClass) invoked to lazily register an unregistered JS
+// subclass the first time it is constructed. Installed via SetLazyClassRegister,
+// this makes registerClass() optional. Empty until JS installs it.
+static Nan::Persistent<Function> lazyClassRegister;
+
+// JS callback invoked the first time a private/non-introspectable concrete type
+// (eg GLocalFile) is wrapped, to mix its implemented interfaces' methods into
+// the class prototype. Installed via SetInterfaceMethodsApplier. See issue #441.
+static Nan::Persistent<Function> interfaceMethodsApplier;
+
 
 static MaybeLocal<FunctionTemplate> GetClassTemplate(GType gtype);
 static MaybeLocal<Function>         GetClass(GType gtype);
@@ -163,7 +175,7 @@ static void ToggleNotify(gpointer user_data, GObject *gobject, gboolean toggle_d
 }
 
 static void AssociateGObject(Local<Object> object, GObject *gobject, GType gtype) {
-    object->SetAlignedPointerInInternalField (0, gobject);
+    Nan::SetInternalFieldPointer(object, 0, gobject);
 
     SET_OBJECT_GTYPE(object, gtype);
 
@@ -219,11 +231,40 @@ static void GObjectConstructor(const FunctionCallbackInfo<Value> &info) {
 
     /* User code calling `new Gtk.Widget({ ... })` */
 
+    // Nan provides Nan::SetPrototype but no GetPrototype wrapper, and V8 14
+    // renamed Object::GetPrototype() to GetPrototypeV2().
+#if defined(V8_MAJOR_VERSION) && V8_MAJOR_VERSION >= 14
+    Local<Object> proto = Nan::To<Object>(self->GetPrototypeV2()).ToLocalChecked();
+#else
+    Local<Object> proto = Nan::To<Object>(self->GetPrototype()).ToLocalChecked();
+#endif
+
+    /* A JS subclass (`class Foo extends Gtk.Widget {}`) that was never passed to
+     * registerClass() owns no GType: `__gtype__` is only *inherited* from its
+     * nearest registered ancestor, so constructing it as-is would silently
+     * instantiate that ancestor — losing the subtype and any vfunc overrides.
+     * Detect the missing *own* property and register the subclass on demand,
+     * which is what makes registerClass() optional. The JS callback installs an
+     * own `__gtype__` on `proto`, so the lookup below resolves to the
+     * freshly-registered subtype. */
+    if (!lazyClassRegister.IsEmpty()
+            && !Nan::HasOwnProperty(proto, UTF8("__gtype__")).FromMaybe(true)) {
+        Local<Function> registerFn = Nan::New<Function>(lazyClassRegister);
+        Local<Value> klass = Nan::Get(proto, UTF8("constructor")).ToLocalChecked();
+        Local<Value> argv[] = { klass };
+        Nan::TryCatch tryCatch;
+        Nan::Call(registerFn, Nan::GetCurrentContext()->Global(), 1, argv);
+        if (tryCatch.HasCaught()) {
+            tryCatch.ReThrow();
+            return;
+        }
+    }
+
     // FIXME: getting the gtype from the External is faster but doesn't
     // work for dynamically-registered types. Check if we can find something
     // better.
     //gtype = (GType) External::Cast(*info.Data())->Value();
-    gtype = GET_OBJECT_GTYPE (Nan::To<Object>(self->GetPrototype()).ToLocalChecked());
+    gtype = GET_OBJECT_GTYPE (proto);
 
     gobject = CreateGObjectFromObject (gtype, info[0]);
 
@@ -330,15 +371,23 @@ static void GObjectClassDestroyed(const Nan::WeakCallbackInfo<GType> &info) {
     (V8_MAJOR_VERSION == 12 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION > 4))
 #define PROPERTY_CALLBACK_RETURN_TYPE v8::Intercepted
 #define PROPERTY_CALLBACK_INFO_TYPE v8::PropertyCallbackInfo<void>
+#define PROPERTY_CALLBACK_INFO_VALUE_TYPE void
+#define PROPERTY_CALLBACK_IS_INTERCEPTED 1
 #else
 #define PROPERTY_CALLBACK_RETURN_TYPE void
 #define PROPERTY_CALLBACK_INFO_TYPE v8::PropertyCallbackInfo<Value>
+#define PROPERTY_CALLBACK_INFO_VALUE_TYPE Value
+#define PROPERTY_CALLBACK_IS_INTERCEPTED 0
 #endif
 
 static PROPERTY_CALLBACK_RETURN_TYPE
 GObjectFallbackPropertyGetter(Local<v8::Name> property,
                               const v8::PropertyCallbackInfo<Value>& info) {
-    auto self = info.Holder();
+    // V8 14 removed PropertyCallbackInfo::Holder(); the Nan wrapper's Holder()
+    // aliases HolderV2() on new V8 and Holder() on older V8. The handler is
+    // installed on InstanceTemplate, so the holder is the instance.
+    Nan::PropertyCallbackInfo<Value> nanInfo(info, info.Data());
+    auto self = nanInfo.Holder();
     GObject *gobject = GObjectFromWrapper (self);
 
     g_assert(gobject != NULL);
@@ -368,7 +417,8 @@ GObjectFallbackPropertyGetter(Local<v8::Name> property,
 static PROPERTY_CALLBACK_RETURN_TYPE
 GObjectFallbackPropertySetter(Local<v8::Name> property, Local<Value> value,
                               const PROPERTY_CALLBACK_INFO_TYPE& info) {
-    auto self = info.Holder();
+    Nan::PropertyCallbackInfo<PROPERTY_CALLBACK_INFO_VALUE_TYPE> nanInfo(info, info.Data());
+    auto self = nanInfo.Holder();
     GObject *gobject = GNodeJS::GObjectFromWrapper (self);
 
     Nan::Utf8String prop_name_v (TO_STRING (property));
@@ -395,8 +445,16 @@ GObjectFallbackPropertySetter(Local<v8::Name> property, Local<Value> value,
         return Nan::Intercepted::No();
     } else {
         // Property exists. Whether we can convert the value and set the
-        // property or not, consider the set intercepted.
+        // property or not, consider the set handled.
+#if !PROPERTY_CALLBACK_IS_INTERCEPTED
+        // Non-intercepted API (V8 <= 12.4): signal "handled" by setting the
+        // return value. Without it V8 falls through and defines a shadowing
+        // own-property on the wrapper, masking the interceptor getter (e.g. a
+        // 64-bit property would then read back as a Number, not a BigInt).
         RETURN(value);
+#endif
+        // Intercepted API (V8 > 12.4): the info is <void>, so signal via the
+        // Intercepted return value rather than by setting a return value.
         g_free(prop_name);
         return Nan::Intercepted::Yes();
     }
@@ -458,6 +516,62 @@ static void DestroyVFuncs(GType gtype) {
     g_type_set_qdata (gtype, GNodeJS::vfuncs_quark(), NULL);
 }
 
+/*
+ * Signal handlers are stored in a JS array held on the wrapper object itself
+ * (via a private symbol), so they are reachable only through the wrapper and
+ * the wrapper <-> handler reference loop can be garbage-collected (#375; see
+ * doc/signal-handler-gc.md). A Closure keeps only its index into that array.
+ */
+static Local<v8::Private> SignalHandlersKey(v8::Isolate *isolate) {
+    return v8::Private::ForApi(isolate, Nan::New("__gnodejs_signal_handlers__").ToLocalChecked());
+}
+
+// Append a handler to the wrapper's handler array, returning its index.
+static guint AddSignalHandler(Local<Object> wrapper, Local<Function> handler) {
+    // Object::GetIsolate() was removed in V8 14; use the current isolate.
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    Local<v8::Context> context = isolate->GetCurrentContext();
+    Local<v8::Private> key = SignalHandlersKey(isolate);
+
+    Local<Value> existing = wrapper->GetPrivate(context, key).ToLocalChecked();
+    Local<Array> handlers;
+    if (existing->IsArray()) {
+        handlers = existing.As<Array>();
+    } else {
+        handlers = Nan::New<Array>();
+        wrapper->SetPrivate(context, key, handlers).Check();
+    }
+
+    guint index = handlers->Length();
+    Nan::Set(handlers, index, handler);
+    return index;
+}
+
+// Look up a handler by the instance it is connected to and its index. Returns
+// an empty handle if the wrapper has been collected or the slot is empty.
+Local<Value> GetSignalHandler(GObject *gobject, guint index) {
+    void *data = g_object_get_qdata (gobject, GNodeJS::object_quark());
+    if (data == NULL)
+        return Local<Value>();
+
+    auto *wrapper = (GObjectWrapper *) data;
+    if (wrapper->collected)
+        return Local<Value>();
+
+    Local<Object> object = Nan::New(wrapper->persistent);
+    if (object.IsEmpty())
+        return Local<Value>();
+
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    Local<v8::Context> context = isolate->GetCurrentContext();
+    Local<Value> handlers =
+        object->GetPrivate(context, SignalHandlersKey(isolate)).ToLocalChecked();
+    if (!handlers->IsArray())
+        return Local<Value>();
+
+    return Nan::Get(handlers.As<Array>(), index).ToLocalChecked();
+}
+
 NAN_METHOD(SignalConnect) {
     bool after = false;
 
@@ -490,9 +604,14 @@ NAN_METHOD(SignalConnect) {
     guint signalId;
     GQuark detail;
     GClosure *gclosure;
+    guint handlerIndex;
     gulong handler_id;
 
-    const char *signalName = *Nan::Utf8String (TO_STRING (info[0]));
+    // Hold the Utf8String for the whole function: `*Nan::Utf8String(...)` alone
+    // dangles after the statement, and AddSignalHandler() below allocates in V8,
+    // which would clobber the freed buffer before g_signal_connect_closure.
+    Nan::Utf8String signalNameValue (TO_STRING (info[0]));
+    const char *signalName = *signalNameValue;
     if (!g_signal_parse_name(signalName, gtype, &signalId, &detail, FALSE)) {
         Nan::ThrowTypeError("Signal name is invalid");
         return;
@@ -506,7 +625,8 @@ NAN_METHOD(SignalConnect) {
         }
     }
 
-    gclosure = Closure::New (callback, signal_info, signalId);
+    handlerIndex = AddSignalHandler (TO_OBJECT (info.This ()), callback);
+    gclosure = Closure::New (handlerIndex, signal_info, signalId);
     handler_id = g_signal_connect_closure (gobject, signalName, gclosure, after);
 
     info.GetReturnValue().Set((double)handler_id);
@@ -628,7 +748,7 @@ NAN_METHOD(GObjectToString) {
 
     const char* typeName = g_type_name(type);
     char *className = *Nan::Utf8String(self->GetConstructorName());
-    void *address = self->GetAlignedPointerFromInternalField(0);
+    void *address = Nan::GetInternalFieldPointer(self, 0);
 
     char *str = g_strdup_printf("[%s:%s %#zx]", typeName, className, (size_t)address);
 
@@ -691,6 +811,60 @@ static MaybeLocal<FunctionTemplate> NewClassTemplate (GType gtype) {
     return MaybeLocal<FunctionTemplate> (tpl);
 }
 
+/*
+ * Mix the methods of a type's implemented interfaces into its class prototype.
+ *
+ * Introspectable object types get this for free: makeObject() in JS iterates
+ * their interfaces and installs the methods. Private/non-introspectable concrete
+ * types (eg GLocalFile, which implements the public GFile interface) are never
+ * seen by makeObject(), so their instances would only expose the base GObject
+ * methods. Here we enumerate the type's introspectable interfaces and hand them
+ * to the JS `interfaceMethodsApplier`, which reuses makeInterface()/define() to
+ * install the methods (and property accessors) on the class prototype.
+ *
+ * See issue #441.
+ */
+static void ApplyInterfaceMethods(Local<Function> constructor, GType gtype) {
+    if (interfaceMethodsApplier.IsEmpty())
+        return;
+
+    guint n_interfaces = 0;
+    GType *interfaces = g_type_interfaces(gtype, &n_interfaces);
+
+    Local<Array> refs = New<Array>();
+    uint32_t count = 0;
+    for (guint i = 0; i < n_interfaces; i++) {
+        GIBaseInfo *iface_info = g_irepository_find_by_gtype(NULL, interfaces[i]);
+        if (iface_info == NULL)
+            continue;
+        if (g_base_info_get_type(iface_info) == GI_INFO_TYPE_INTERFACE) {
+            Local<Object> ref = New<Object>();
+            Nan::Set(ref, UTF8("namespace"), UTF8(g_base_info_get_namespace(iface_info)));
+            Nan::Set(ref, UTF8("name"),      UTF8(g_base_info_get_name(iface_info)));
+            Nan::Set(refs, count++, ref);
+        }
+        g_base_info_unref(iface_info);
+    }
+    g_free(interfaces);
+
+    if (count == 0)
+        return;
+
+    Local<Function> applier = New<Function>(interfaceMethodsApplier);
+    Local<Value> argv[] = { constructor, refs };
+    Nan::TryCatch tryCatch;
+    Nan::Call(applier, Nan::GetCurrentContext()->Global(), 2, argv);
+    if (tryCatch.HasCaught()) {
+        Nan::Utf8String message(tryCatch.Exception());
+        g_warning("node-gtk: could not apply interface methods for %s: %s",
+                  g_type_name(gtype), *message);
+    }
+}
+
+NAN_METHOD(SetInterfaceMethodsApplier) {
+    interfaceMethodsApplier.Reset(info[0].As<Function>());
+}
+
 static MaybeLocal<FunctionTemplate> GetClassTemplate(GType gtype) {
     void *data = g_type_get_qdata (gtype, GNodeJS::template_quark());
 
@@ -718,6 +892,15 @@ static MaybeLocal<FunctionTemplate> GetClassTemplate(GType gtype) {
     g_type_set_qdata(gtype, GNodeJS::template_quark(), persistentTpl);
     g_type_set_qdata(gtype, GNodeJS::function_quark(), persistentFn);
 
+    // Introspectable object types have their interface methods installed by
+    // makeObject() in JS. Private concrete types are never seen there, so mix
+    // in their interface methods now (issue #441).
+    GIBaseInfo *own_info = g_irepository_find_by_gtype(NULL, gtype);
+    if (own_info == NULL)
+        ApplyInterfaceMethods(fn, gtype);
+    else
+        g_base_info_unref(own_info);
+
     return MaybeLocal<FunctionTemplate> (tpl);
 }
 
@@ -798,7 +981,7 @@ GObject * GObjectFromWrapper(Local<Value> value) {
 
     Local<Object> object = TO_OBJECT (value);
 
-    void    *ptr     = object->GetAlignedPointerFromInternalField (0);
+    void    *ptr     = Nan::GetInternalFieldPointer(object, 0);
     GObject *gobject = G_OBJECT (ptr);
     return gobject;
 }
@@ -964,6 +1147,10 @@ out:
 }
 
 
+NAN_METHOD(SetLazyClassRegister) {
+    lazyClassRegister.Reset(info[0].As<Function>());
+}
+
 NAN_METHOD(RegisterClass) {
     auto jsKlassName  = Nan::To<String>(info[0]).ToLocalChecked();
     auto jsKlass      = info[1].As<Object>();
@@ -1034,6 +1221,78 @@ NAN_METHOD(RegisterVFunc) {
     return;
 }
 
+/*
+ * Invoke a parent class's implementation of a vfunc — the native half of
+ * `super.<vfunc>(...)`. JS args: (vfuncInfo, implementorGType, instance, argsArray).
+ *
+ * `g_vfunc_info_invoke` resolves the vfunc through `implementorGType`'s class
+ * vtable, so passing the *parent* GType runs the parent's implementation rather
+ * than the overriding subclass's (which is what `super` means). The instance is
+ * passed as in-arg 0, the JS args follow.
+ *
+ * Scope: in-only arguments + (void or simple) return value. Out/inout arguments
+ * are rejected rather than silently mishandled.
+ */
+NAN_METHOD(CallVFunc) {
+    auto jsVFuncInfo  = info[0].As<Object>();
+    auto jsImplGType  = info[1].As<BigInt>();
+    auto jsInstance   = info[2];
+    auto jsArgs       = info[3].As<Array>();
+
+    BaseInfo vfuncInfo(jsVFuncInfo);
+    GType implementor = jsImplGType->Uint64Value();
+
+    int n_callable = g_callable_info_get_n_args(*vfuncInfo);
+
+    GObject *instance = GObjectFromWrapper(jsInstance);
+    if (instance == NULL) {
+        // The wrapper has no associated GObject yet — e.g. chaining up to a
+        // construction-time vfunc (`constructed`), which fires inside g_object_new
+        // before node-gtk associates the JS wrapper with the GObject. There is no
+        // valid instance to invoke the parent on; fail loudly instead of crashing.
+        Throw::Error("Cannot chain up to parent vfunc '%s': instance has no GObject yet "
+                "(chaining up during construction is unsupported)",
+                g_base_info_get_name(*vfuncInfo));
+        return;
+    }
+
+    std::vector<GIArgument> in_args(n_callable + 1);
+    in_args[0].v_pointer = instance;
+
+    for (int i = 0; i < n_callable; i++) {
+        GIArgInfo arg_info;
+        GITypeInfo arg_type;
+        g_callable_info_load_arg(*vfuncInfo, i, &arg_info);
+        g_arg_info_load_type(&arg_info, &arg_type);
+
+        if (g_arg_info_get_direction(&arg_info) != GI_DIRECTION_IN) {
+            Throw::Error("Cannot chain up to parent vfunc '%s': out/inout argument %d is unsupported",
+                    g_base_info_get_name(*vfuncInfo), i);
+            return;
+        }
+
+        Local<Value> value = Nan::Get(jsArgs, i).ToLocalChecked();
+        bool may_be_null = g_arg_info_may_be_null(&arg_info);
+        V8ToGIArgument(&arg_type, &in_args[i + 1], value, may_be_null);
+    }
+
+    GIArgument return_value = {};
+    GError *error = NULL;
+    gboolean ok = g_vfunc_info_invoke(*vfuncInfo, implementor,
+            in_args.data(), n_callable + 1, NULL, 0, &return_value, &error);
+
+    if (!ok) {
+        Throw::GError("Failed to chain up to parent vfunc", error);
+        return;
+    }
+
+    GITypeInfo return_type;
+    g_callable_info_load_return_type(*vfuncInfo, &return_type);
+    if (g_type_info_get_tag(&return_type) != GI_TYPE_TAG_VOID) {
+        info.GetReturnValue().Set(GIArgumentToV8(&return_type, &return_value));
+    }
+}
+
 };
 
 };

package/src/gobject.h

@@ -18,14 +18,19 @@ namespace GNodeJS {
 MaybeLocal<Function>    MakeClass            (GIBaseInfo *info);
 Local<Value>            WrapperFromGObject   (GObject *object);
 GObject *               GObjectFromWrapper   (Local<Value> value);
+Local<Value>            GetSignalHandler     (GObject *gobject, guint index);
 Local<FunctionTemplate> GetBaseClassTemplate ();
 MaybeLocal<Value>       GetGObjectProperty   (GObject * gobject, const char *prop_name);
 MaybeLocal<v8::Boolean> SetGObjectProperty   (GObject * gobject, const char *prop_name, Local<Value> value);
 
+NAN_METHOD(SetInterfaceMethodsApplier);
+
 namespace ObjectClass {
 
+NAN_METHOD(SetLazyClassRegister);
 NAN_METHOD(RegisterClass);
 NAN_METHOD(RegisterVFunc);
+NAN_METHOD(CallVFunc);
 
 };