@gtkx/ffi 0.14.0 → 0.16.0

package/dist/generated/gobject/c-closure.js

@@ -1,5 +1,1548 @@
+import { alloc, read } from "@gtkx/native";
+import { call } from "../../batch.js";
 import { NativeObject } from "../../native/base.js";
-/** Stub class for CClosure (opaque type not fully generated) */
+/** A #GCClosure is a specialization of #GClosure for C function callbacks. */
 export class CClosure extends NativeObject {
-    static objectType = "boxed";
+    static objectType = "struct";
+    constructor() {
+        super();
+        this.handle = alloc(64);
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with handlers that
+     * take two boxed pointers as arguments and return a boolean.  If you
+     * have such a signal, you will probably also need to use an
+     * accumulator, such as g_signal_accumulator_true_handled().
+     */
+    static marshal_BOOLEAN__BOXED_BOXED(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_BOOLEAN__BOXED_BOXED", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with handlers that
+     * take a flags type as an argument and return a boolean.  If you have
+     * such a signal, you will probably also need to use an accumulator,
+     * such as g_signal_accumulator_true_handled().
+     */
+    static marshal_BOOLEAN__FLAGS(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_BOOLEAN__FLAGS", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with handlers that
+     * take a #GObject and a pointer and produce a string.  It is highly
+     * unlikely that your signal handler fits this description.
+     */
+    static marshal_STRING__OBJECT_POINTER(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_STRING__OBJECT_POINTER", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * boolean argument.
+     */
+    static marshal_VOID__BOOLEAN(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__BOOLEAN", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * argument which is any boxed pointer type.
+     */
+    static marshal_VOID__BOXED(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__BOXED", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * character argument.
+     */
+    static marshal_VOID__CHAR(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__CHAR", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with one
+     * double-precision floating point argument.
+     */
+    static marshal_VOID__DOUBLE(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__DOUBLE", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * argument with an enumerated type.
+     */
+    static marshal_VOID__ENUM(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__ENUM", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * argument with a flags types.
+     */
+    static marshal_VOID__FLAGS(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__FLAGS", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with one
+     * single-precision floating point argument.
+     */
+    static marshal_VOID__FLOAT(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__FLOAT", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * integer argument.
+     */
+    static marshal_VOID__INT(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__INT", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with with a single
+     * long integer argument.
+     */
+    static marshal_VOID__LONG(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__LONG", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * #GObject argument.
+     */
+    static marshal_VOID__OBJECT(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__OBJECT", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * argument of type #GParamSpec.
+     */
+    static marshal_VOID__PARAM(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__PARAM", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single raw
+     * pointer argument type.
+     *
+     * If it is possible, it is better to use one of the more specific
+     * functions such as g_cclosure_marshal_VOID__OBJECT() or
+     * g_cclosure_marshal_VOID__OBJECT().
+     */
+    static marshal_VOID__POINTER(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__POINTER", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single string
+     * argument.
+     */
+    static marshal_VOID__STRING(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__STRING", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * unsigned character argument.
+     */
+    static marshal_VOID__UCHAR(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UCHAR", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with with a single
+     * unsigned integer argument.
+     */
+    static marshal_VOID__UINT(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UINT", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with an unsigned int
+     * and a pointer as arguments.
+     */
+    static marshal_VOID__UINT_POINTER(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UINT_POINTER", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * unsigned long integer argument.
+     */
+    static marshal_VOID__ULONG(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__ULONG", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A #GClosureMarshal function for use with signals with a single
+     * #GVariant argument.
+     */
+    static marshal_VOID__VARIANT(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__VARIANT", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /** A #GClosureMarshal function for use with signals with no arguments. */
+    static marshal_VOID__VOID(closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__VOID", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnValue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * A generic marshaller function implemented via
+     * [libffi](http://sourceware.org/libffi/).
+     *
+     * Normally this function is not passed explicitly to g_signal_new(),
+     * but used automatically by GLib when specifying a %NULL marshaller.
+     */
+    static marshalGeneric(closure, returnGvalue, nParamValues, paramValues, invocationHint, marshalData) {
+        call("libgobject-2.0.so.0", "g_cclosure_marshal_generic", [
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GClosure",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: closure.handle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: returnGvalue.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nParamValues,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "borrowed",
+                    innerType: "GValue",
+                    library: "libgobject-2.0.so.0",
+                    getTypeFn: "g_value_get_type",
+                },
+                value: paramValues.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: invocationHint,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: marshalData,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /** the #GClosure */
+    getClosure() {
+        return read(this.handle, {
+            type: "boxed",
+            ownership: "full",
+            innerType: "GClosure",
+            library: "libgobject-2.0.so.0",
+            getTypeFn: "g_closure_get_type",
+        }, 0);
+    }
 }