node-gtk 2.1.0 → 3.0.0

package/scripts/windows-bundle-runtime.sh

@@ -0,0 +1,163 @@
+#!/bin/bash
+#
+# windows-bundle-runtime.sh
+#
+# Make a freshly-built Windows prebuilt self-contained so it can be used WITHOUT
+# MSYS2/MinGW or any compiler on the target machine. We copy the addon's entire
+# transitive MinGW DLL closure next to the .node, plus the GObject-Introspection
+# typelibs and runtime data it needs at runtime.
+#
+# The set of bundled libraries is driven by the curated seed list
+# windows/runtime-libraries.txt (also a user-facing reference). The exact
+# resolved DLL set is written to <binding-dir>/bundled-dlls.txt.
+#
+# Run inside the MINGW64 shell, after building.
+#
+#   ./scripts/windows-bundle-runtime.sh lib/binding/node-v127-win32-x64
+#
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+
+BINDING_DIR="${1:?usage: windows-bundle-runtime.sh <binding-dir> [runtime-libraries.txt]}"
+# The curated seed list lives in a text file so it doubles as user-facing
+# reference (windows/runtime-libraries.txt). Override with $2 if needed.
+LIBS_FILE="${2:-$SCRIPT_DIR/../windows/runtime-libraries.txt}"
+# MinGW bin dir the seed names resolve against.
+MB="${MINGW_BIN:-/mingw64/bin}"
+
+NODE_FILE="$BINDING_DIR/node_gtk.node"
+
+if [ ! -f "$NODE_FILE" ]; then
+  echo "error: $NODE_FILE not found"
+  ls -la "$BINDING_DIR" || true
+  exit 1
+fi
+if [ ! -f "$LIBS_FILE" ]; then
+  echo "error: seed list $LIBS_FILE not found"
+  exit 1
+fi
+
+# GObject-Introspection loads each namespace's shared library at runtime via
+# g_module_open() when you call gi.require('Gtk', ...). Those libraries
+# (libgio, libgtk, libgdk, libpango, libgdk_pixbuf, ...) are NOT linked by
+# node_gtk.node, so ntldd on the addon alone misses them. We therefore seed the
+# closure from the addon AND from the GTK runtime libraries listed in LIBS_FILE.
+echo "## Seed libraries from $LIBS_FILE"
+ENTRY_LIBS=("$NODE_FILE")
+while IFS= read -r line; do
+  # strip comments and surrounding whitespace; skip blanks
+  name="${line%%#*}"
+  name="$(echo "$name" | tr -d '[:space:]')"
+  [ -z "$name" ] && continue
+  if [ -f "$MB/$name" ]; then
+    ENTRY_LIBS+=("$MB/$name")
+    echo "  - $name"
+  else
+    echo "  (skip missing seed $name)"
+  fi
+done < "$LIBS_FILE"
+
+echo "## Computing recursive DLL closure for the addon + GTK runtime"
+# ntldd -R prints every transitive dependency with its resolved Windows path:
+#   libgtk-3-0.dll => C:\msys64\mingw64\bin\libgtk-3-0.dll (0x...)
+# Collect the union of every entry's closure, keep only MinGW-provided DLLs
+# (skip C:\Windows\System32 OS DLLs), and copy them next to the .node.
+: > /tmp/dll-closure.txt
+for lib in "${ENTRY_LIBS[@]}"; do
+  [ -f "$lib" ] || { echo "  (skip missing entry $lib)"; continue; }
+  # the entry library itself (when it is one of the GTK runtime DLLs)
+  case "$lib" in *mingw64*) echo "$lib" >> /tmp/dll-closure.txt ;; esac
+  ntldd -R "$lib" \
+    | sed -n 's/.* => \(.*\) (0x.*/\1/p' \
+    | while IFS= read -r winpath; do
+        [ -z "$winpath" ] && continue
+        u=$(cygpath -u "$winpath" 2>/dev/null || echo "$winpath")
+        case "$u" in *mingw64*) echo "$u" >> /tmp/dll-closure.txt ;; esac
+      done
+done
+
+copied=0
+sort -u /tmp/dll-closure.txt | while IFS= read -r u; do
+  if [ -f "$u" ]; then
+    cp -f "$u" "$BINDING_DIR/"
+    echo "  + $(basename "$u")"
+    copied=$((copied + 1))
+  fi
+done
+DLL_COUNT=$(ls "$BINDING_DIR"/*.dll 2>/dev/null | wc -l | tr -d ' ')
+echo "## DLLs bundled into $BINDING_DIR ($DLL_COUNT total)"
+
+# Write the exact set that shipped, as a reference manifest (ships in the
+# bundle and the artifact). Generated from the curated seed list above.
+MANIFEST="$BINDING_DIR/bundled-dlls.txt"
+{
+  echo "# bundled-dlls.txt — Windows DLLs shipped with this node-gtk prebuilt."
+  echo "# GENERATED by scripts/windows-bundle-runtime.sh; do not edit by hand."
+  echo "# Edit the curated seed list windows/runtime-libraries.txt instead."
+  echo "# $DLL_COUNT DLLs, expanded from the seed list via 'ntldd -R'."
+  echo "#"
+  ( cd "$BINDING_DIR" && ls -1 *.dll 2>/dev/null | sort )
+} > "$MANIFEST"
+echo "## Wrote manifest $MANIFEST"
+
+echo "## Bundling GObject-Introspection typelibs"
+TYPELIB_SRC=$(pkg-config --variable=typelibdir gobject-introspection-1.0 2>/dev/null || true)
+if [ -z "$TYPELIB_SRC" ] || [ ! -d "$TYPELIB_SRC" ]; then
+  TYPELIB_SRC=/mingw64/lib/girepository-1.0
+fi
+TYPELIB_DST="$BINDING_DIR/girepository-1.0"
+mkdir -p "$TYPELIB_DST"
+# Copy the full typelib set; it is small and guarantees every transitive
+# namespace dependency (Gdk, Pango, cairo, GdkPixbuf, Graphene, ...) is present.
+cp -f "$TYPELIB_SRC"/*.typelib "$TYPELIB_DST/"
+echo "## Typelibs bundled from $TYPELIB_SRC -> $TYPELIB_DST"
+
+# ---------------------------------------------------------------------------
+# Runtime DATA a real GTK4/Adwaita app needs at run time (beyond DLLs/typelibs).
+# These are copied so we can MEASURE the realistic bundle size and ship a
+# self-contained app. cp is best-effort: a missing source is not fatal.
+# ---------------------------------------------------------------------------
+copy_tree() { # src dst
+  if [ -d "$1" ]; then mkdir -p "$2"; cp -rf "$1"/. "$2"/ 2>/dev/null || true; fi
+}
+
+echo "## Bundling runtime data (loaders, schemas, icons, gtksourceview)"
+# gdk-pixbuf image loaders (PNG/SVG/... — needed for icons/images)
+copy_tree /mingw64/lib/gdk-pixbuf-2.0 "$BINDING_DIR/lib/gdk-pixbuf-2.0"
+# compiled GSettings schemas (GTK4/Adw/GtkSourceView read settings)
+copy_tree /mingw64/share/glib-2.0/schemas "$BINDING_DIR/share/glib-2.0/schemas"
+# icon themes (Adwaita + hicolor fallback) — typically the biggest chunk
+copy_tree /mingw64/share/icons/Adwaita "$BINDING_DIR/share/icons/Adwaita"
+copy_tree /mingw64/share/icons/hicolor "$BINDING_DIR/share/icons/hicolor"
+# GtkSourceView language definitions + style schemes
+copy_tree /mingw64/share/gtksourceview-5 "$BINDING_DIR/share/gtksourceview-5"
+
+# Make the gdk-pixbuf loaders cache path-portable: the build machine bakes in
+# absolute paths to each loader DLL, which don't exist on the user's machine.
+# Rewrite each loader path to its bare file name; lib/native.js puts the loaders
+# dir on PATH so g_module_open() resolves the bare name at run time.
+LOADER_CACHE="$BINDING_DIR/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache"
+if [ -f "$LOADER_CACHE" ]; then
+  sed -i -E 's#^"[^"]*[\\/]([^"\\/]+\.dll)"#"\1"#' "$LOADER_CACHE"
+  echo "## Rewrote $LOADER_CACHE to portable (bare) loader names"
+fi
+
+echo
+echo "## ===== SIZE BREAKDOWN ====="
+size() { # label dir-or-glob
+  local label="$1"; shift
+  local total
+  total=$(du -ch "$@" 2>/dev/null | tail -1 | cut -f1)
+  printf '  %-26s %s\n' "$label" "${total:-0}"
+}
+size "DLLs (load-critical)"        "$BINDING_DIR"/*.dll
+size "typelibs (load-critical)"    "$TYPELIB_DST"
+size "  + .node"                   "$NODE_FILE"
+size "gdk-pixbuf loaders"          "$BINDING_DIR/lib/gdk-pixbuf-2.0"
+size "glib schemas"                "$BINDING_DIR/share/glib-2.0/schemas"
+size "icons (Adwaita+hicolor)"     "$BINDING_DIR/share/icons"
+size "gtksourceview data"          "$BINDING_DIR/share/gtksourceview-5"
+echo "  --------------------------------------"
+size "TOTAL (uncompressed)"        "$BINDING_DIR"
+echo "## =========================="

package/scripts/windows-smoke-test.js

@@ -0,0 +1,104 @@
+/*
+ * windows-smoke-test.js
+ *
+ * Verifies that a Windows prebuilt + bundled GTK runtime can be loaded and used
+ * on a clean machine that has NO MSYS2/MinGW and NO compiler — i.e. exactly what
+ * a user gets from `npm install node-gtk`.
+ *
+ * CRITICAL: this test sets NO environment variables. Everything (DLL search
+ * path, GI typelib path, icon/schema/loader data) is wired up automatically by
+ * lib/native.js when it loads the bundled prebuilt. The workflow runs this with
+ * the runner's own MinGW stripped from PATH, so a pass proves the bundle is
+ * fully self-sufficient via the auto-wiring alone.
+ */
+
+const path = require('path')
+const fs = require('fs')
+
+const abi = process.versions.modules
+const bindingDir = path.join(__dirname, '..', 'lib', 'binding', `node-v${abi}-win32-x64`)
+const typelibDir = path.join(bindingDir, 'girepository-1.0')
+
+console.log('node:', process.version, '| abi:', abi)
+console.log('binding dir:', bindingDir, '| exists:', fs.existsSync(bindingDir))
+console.log('.node:', fs.existsSync(path.join(bindingDir, 'node_gtk.node')))
+console.log('typelibs:', fs.existsSync(typelibDir))
+if (fs.existsSync(bindingDir)) {
+  const dlls = fs.readdirSync(bindingDir).filter(f => f.endsWith('.dll'))
+  console.log(`bundled DLLs: ${dlls.length}`)
+}
+
+// Require the local package. lib/native.js resolves the prebuilt via
+// node-pre-gyp's binary.find and auto-wires the bundled runtime — NO manual
+// PATH / GI_TYPELIB_PATH / XDG_DATA_DIRS setup here on purpose.
+const gi = require(path.join(__dirname, '..'))
+console.log('OK: require(node-gtk) — prebuilt loaded and runtime auto-wired by native.js')
+
+// The full quilx namespace set. Vte (3.91) has no Windows port, so it is
+// expected to be unavailable; everything else must load.
+const REQUIRED = [
+  ['GLib', '2.0'], ['GObject', '2.0'], ['Gio', '2.0'],
+  ['Pango', '1.0'], ['PangoCairo', '1.0'],
+  ['Gdk', '4.0'], ['GdkPixbuf', '2.0'], ['Graphene', '1.0'],
+  ['Gtk', '4.0'], ['Adw', '1'], ['GtkSource', '5'],
+]
+const OPTIONAL = [['Vte', '3.91']]
+
+const loaded = {}
+function load(ns, version, optional) {
+  try {
+    const mod = gi.require(ns, version)
+    console.log(`OK: gi.require('${ns}', '${version}')`)
+    loaded[ns] = mod
+    return mod
+  } catch (e) {
+    console.log(`${optional ? 'note' : 'FAIL'}: gi.require('${ns}', '${version}') — ${e.message}`)
+    if (!optional) throw e
+    return null
+  }
+}
+
+for (const [ns, v] of REQUIRED) load(ns, v, false)
+for (const [ns, v] of OPTIONAL) load(ns, v, true)
+
+// Sanity: the typelibs really resolved their symbols.
+if (typeof loaded.GLib.getMonotonicTime !== 'function')
+  throw new Error('GLib.getMonotonicTime missing — typelib not really loaded')
+if (typeof loaded.Gtk.Window !== 'function')
+  throw new Error('Gtk.Window missing — Gtk4 typelib not really loaded')
+if (typeof loaded.Adw.ApplicationWindow !== 'function')
+  throw new Error('Adw.ApplicationWindow missing — libadwaita not really loaded')
+
+// Exercise a real GTK4 + Adwaita object graph (needs a display; the runner has one).
+let appOk = false
+try {
+  loaded.Gtk.init()
+  const win = new loaded.Adw.ApplicationWindow()
+  const buffer = new loaded.GtkSource.Buffer()
+  const view = new loaded.GtkSource.View()
+  view.setBuffer(buffer)
+  win.setContent(view)
+  console.log('OK: created Adw.ApplicationWindow + GtkSource.View')
+  appOk = true
+} catch (e) {
+  console.log('note: live widget creation threw (likely no display):', e.message)
+}
+console.log('live GTK4/Adwaita widgets:', appOk ? 'ok' : 'skipped (no display)')
+
+// Exercise the bundled gdk-pixbuf image loaders + (portable) loaders.cache by
+// decoding a real PNG. This proves the loader subsystem works from the bundle.
+const PNG_1x1 = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC',
+  'base64')
+const pngPath = path.join(__dirname, '..', 'smoke-test-pixel.png')
+fs.writeFileSync(pngPath, PNG_1x1)
+try {
+  const pixbuf = loaded.GdkPixbuf.Pixbuf.newFromFile(pngPath)
+  if (pixbuf.getWidth() !== 1 || pixbuf.getHeight() !== 1)
+    throw new Error(`unexpected pixbuf size ${pixbuf.getWidth()}x${pixbuf.getHeight()}`)
+  console.log('OK: GdkPixbuf decoded a PNG via the bundled loaders')
+} finally {
+  try { fs.unlinkSync(pngPath) } catch (e) { /* ignore */ }
+}
+
+console.log('\n=== SMOKE TEST PASSED: GTK4/Adwaita prebuilt usable with NO compiler/MSYS2 ===')

package/src/closure.cc

@@ -3,6 +3,7 @@
 
 #include "closure.h"
 #include "error.h"
+#include "gobject.h"
 #include "macros.h"
 #include "loop.h"
 #include "type.h"
@@ -54,9 +55,9 @@ static void LoadGIArgumentFromPointer (GITypeInfo *type_info, GIArgument *arg) {
     }
 }
 
-GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint signalId) {
+GClosure *Closure::New (guint handlerIndex, GICallableInfo* info, guint signalId) {
     Closure *closure = (Closure *) g_closure_new_simple (sizeof (*closure), GUINT_TO_POINTER(signalId));
-    closure->persistent.Reset(function);
+    closure->handlerIndex = handlerIndex;
     if (info) {
         closure->info = g_base_info_ref(info);
     } else {
@@ -69,11 +70,18 @@ GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint si
 }
 
 void Closure::Execute(GICallableInfo *info, guint signal_id,
-                      const Nan::Persistent<v8::Function> &persFn,
+                      GObject *instance, guint handlerIndex,
                       GValue *g_return_value, guint n_param_values,
                       const GValue *param_values) {
     Nan::HandleScope scope;
-    auto func = Nan::New<Function>(persFn);
+
+    /* The handler lives in a JS array on the instance's wrapper (#375). If the
+     * wrapper has been collected (the object was dropped from JS) there is
+     * nothing to call. */
+    Local<Value> handlerValue = GetSignalHandler(instance, handlerIndex);
+    if (handlerValue.IsEmpty() || !handlerValue->IsFunction())
+        return;
+    auto func = handlerValue.As<Function>();
 
     GSignalQuery signal_query = { 0, };
 
@@ -242,16 +250,21 @@ void Closure::Marshal(GClosure     *base,
 
     auto closure = (Closure *) base;
     auto signal_id = GPOINTER_TO_UINT(marshal_data);
+    auto handlerIndex = closure->handlerIndex;
+
+    /* param_values[0] is always the instance the signal was emitted on, which
+     * is the object whose wrapper holds this handler (#375). */
+    GObject *instance = (GObject *) g_value_get_object(&param_values[0]);
 
     AsyncCallEnvironment* env = reinterpret_cast<AsyncCallEnvironment *>(AsyncCallEnvironment::asyncHandle.data);
 
     if (env->IsSameThread()) {
         /* Case 1: same thread */
-        Closure::Execute(closure->info, signal_id, closure->persistent, g_return_value, n_param_values, param_values);
+        Closure::Execute(closure->info, signal_id, instance, handlerIndex, g_return_value, n_param_values, param_values);
     } else {
         /* Case 2: different thread */
         env->Call([&]() {
-            Closure::Execute(closure->info, signal_id, closure->persistent, g_return_value, n_param_values, param_values);
+            Closure::Execute(closure->info, signal_id, instance, handlerIndex, g_return_value, n_param_values, param_values);
         });
     }
 }

package/src/closure.h

@@ -16,20 +16,24 @@ namespace GNodeJS {
 
 struct Closure {
     GClosure base;
-    Nan::Persistent<v8::Function> persistent;
+    /* The handler function is NOT held here. It lives in a JS array on the
+     * wrapper object (reachable only through the wrapper), and we keep just its
+     * index. This breaks the wrapper <-> handler reference loop that a strong
+     * Nan::Persistent used to create and leak (#375); see
+     * doc/signal-handler-gc.md. */
+    guint handlerIndex;
     GICallableInfo* info;
 
     ~Closure() {
-        persistent.Reset();
         if (info) g_base_info_unref (info);
     }
 
-    static GClosure *New(Local<Function> function,
+    static GClosure *New(guint handlerIndex,
                          GICallableInfo* info,
                          guint signalId);
 
     static void Execute(GICallableInfo *info, guint signal_id,
-                        const Nan::Persistent<v8::Function> &persFn,
+                        GObject *instance, guint handlerIndex,
                         GValue *g_return_value, guint n_param_values,
                         const GValue *param_values);
 

package/src/function.cc

@@ -134,6 +134,43 @@ bool IsDestroyNotify (GIBaseInfo *info) {
         && strcmp(g_base_info_get_namespace(info), "GLib") == 0;
 }
 
+/*
+ * A transfer-full GObject return value hands node-gtk an *owning* reference. The
+ * JS wrapper only needs node-gtk's toggle reference, so that extra reference has
+ * to be released — otherwise the refcount never falls back to 1, ToggleNotify
+ * never flips the V8 handle to weak, and the GObject (plus its wrapper) leaks for
+ * the lifetime of the process. This is the leak reported in #446: objects from
+ * GI function returns (`Type.new()`, transfer-full getters, …) were never GC'd,
+ * while `new Type()` — which drops its construction ref in GObjectConstructor —
+ * was. It is the return-value counterpart of OUT GObject args, which
+ * FreeGIArgument already balances; the return value is otherwise never freed on
+ * the success path. (The IN counterpart is RefObjectForTransferFullIn, #439.)
+ *
+ * Must be sampled *before* the value is wrapped: associating the wrapper sinks a
+ * floating reference (consuming it), after which a floating incoming ref (nothing
+ * extra to drop) is indistinguishable from a real owned one. G_IS_OBJECT excludes
+ * GParamSpec (wrapped via ParamSpec::FromGParamSpec) and boxed/fundamental
+ * interface types.
+ */
+static bool OwnsExtraGObjectReturnRef(GITypeInfo *return_type, GITransfer transfer, gpointer ptr) {
+    if (transfer != GI_TRANSFER_EVERYTHING || ptr == NULL)
+        return false;
+
+    if (g_type_info_get_tag(return_type) != GI_TYPE_TAG_INTERFACE)
+        return false;
+
+    GIBaseInfo *iface = g_type_info_get_interface(return_type);
+    GIInfoType  itype = g_base_info_get_type(iface);
+
+    bool result =
+        (itype == GI_INFO_TYPE_OBJECT || itype == GI_INFO_TYPE_INTERFACE)
+        && G_IS_OBJECT(ptr)
+        && !g_object_is_floating(ptr);
+
+    g_base_info_unref(iface);
+    return result;
+}
+
 
 /**
  * The constructor just stores the GIBaseInfo ref. The rest of the
@@ -549,6 +586,13 @@ Local<Value> FunctionCall (
 
     } else if (!use_return_value) {
 
+        // A transfer-full GObject return hands us an extra owning reference on
+        // top of the wrapper's toggle ref; drop it once wrapped so the object
+        // isn't pinned alive forever (#446). Sampled now, before wrapping sinks
+        // any floating reference.
+        bool release_return_ref =
+            OwnsExtraGObjectReturnRef(&return_type, return_transfer, return_value_stack.v_pointer);
+
         // Value transferred to jsReturnValue
         jsReturnValue = func->JsReturnValue (
                 info.This(),
@@ -556,6 +600,9 @@ Local<Value> FunctionCall (
                 &return_value_stack,
                 callable_arg_values,
                 return_transfer);
+
+        if (release_return_ref)
+            g_object_unref (return_value_stack.v_pointer);
     } else {
 
         // Value returned in return_value

package/src/gi.cc

@@ -405,6 +405,10 @@ NAN_METHOD(GetModuleCache) {
     info.GetReturnValue().Set(Nan::New<Object>(GNodeJS::moduleCache));
 }
 
+NAN_METHOD(SetLazyClassRegister) {
+    GNodeJS::ObjectClass::SetLazyClassRegister(info);
+}
+
 NAN_METHOD(RegisterClass) {
     GNodeJS::ObjectClass::RegisterClass(info);
 }
@@ -413,6 +417,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 +439,10 @@ 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, "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());