@gtkx/ffi 0.10.0 → 0.10.1

package/dist/generated/gstbase/base-src.d.ts

@@ -1,120 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
-/**
- * This is a generic base class for source elements. The following
- * types of sources are supported:
- *
- * * random access sources like files
- * * seekable sources
- * * live sources
- *
- * The source can be configured to operate in any #GstFormat with the
- * gst_base_src_set_format() method. The currently set format determines
- * the format of the internal #GstSegment and any %GST_EVENT_SEGMENT
- * events. The default format for #GstBaseSrc is %GST_FORMAT_BYTES.
- *
- * #GstBaseSrc always supports push mode scheduling. If the following
- * conditions are met, it also supports pull mode scheduling:
- *
- * * The format is set to %GST_FORMAT_BYTES (default).
- * * #GstBaseSrcClass::is_seekable returns %TRUE.
- *
- * If all the conditions are met for operating in pull mode, #GstBaseSrc is
- * automatically seekable in push mode as well. The following conditions must
- * be met to make the element seekable in push mode when the format is not
- * %GST_FORMAT_BYTES:
- *
- * * #GstBaseSrcClass::is_seekable returns %TRUE.
- * * #GstBaseSrcClass::query can convert all supported seek formats to the
- * internal format as set with gst_base_src_set_format().
- * * #GstBaseSrcClass::do_seek is implemented, performs the seek and returns
- * %TRUE.
- *
- * When the element does not meet the requirements to operate in pull mode, the
- * offset and length in the #GstBaseSrcClass::create method should be ignored.
- * It is recommended to subclass #GstPushSrc instead, in this situation. If the
- * element can operate in pull mode but only with specific offsets and
- * lengths, it is allowed to generate an error when the wrong values are passed
- * to the #GstBaseSrcClass::create function.
- *
- * #GstBaseSrc has support for live sources. Live sources are sources that when
- * paused discard data, such as audio or video capture devices. A typical live
- * source also produces data at a fixed rate and thus provides a clock to publish
- * this rate.
- * Use gst_base_src_set_live() to activate the live source mode.
- *
- * A live source does not produce data in the PAUSED state. This means that the
- * #GstBaseSrcClass::create method will not be called in PAUSED but only in
- * PLAYING. To signal the pipeline that the element will not produce data, the
- * return value from the READY to PAUSED state will be
- * %GST_STATE_CHANGE_NO_PREROLL.
- *
- * A typical live source will timestamp the buffers it creates with the
- * current running time of the pipeline. This is one reason why a live source
- * can only produce data in the PLAYING state, when the clock is actually
- * distributed and running.
- *
- * Live sources that synchronize and block on the clock (an audio source, for
- * example) can use gst_base_src_wait_playing() when the
- * #GstBaseSrcClass::create function was interrupted by a state change to
- * PAUSED.
- *
- * The #GstBaseSrcClass::get_times method can be used to implement pseudo-live
- * sources. It only makes sense to implement the #GstBaseSrcClass::get_times
- * function if the source is a live source. The #GstBaseSrcClass::get_times
- * function should return timestamps starting from 0, as if it were a non-live
- * source. The base class will make sure that the timestamps are transformed
- * into the current running_time. The base source will then wait for the
- * calculated running_time before pushing out the buffer.
- *
- * For live sources, the base class will by default report a latency of 0.
- * For pseudo live sources, the base class will by default measure the difference
- * between the first buffer timestamp and the start time of get_times and will
- * report this value as the latency.
- * Subclasses should override the query function when this behaviour is not
- * acceptable.
- *
- * There is only support in #GstBaseSrc for exactly one source pad, which
- * should be named "src". A source implementation (subclass of #GstBaseSrc)
- * should install a pad template in its class_init function, like so:
- * |[<!-- language="C" -->
- * static void
- * my_element_class_init (GstMyElementClass *klass)
- * {
- * GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
- * // srctemplate should be a #GstStaticPadTemplate with direction
- * // %GST_PAD_SRC and name "src"
- * gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
- *
- * gst_element_class_set_static_metadata (gstelement_class,
- * "Source name",
- * "Source",
- * "My Source element",
- * "The author <my.sink`my`.email>");
- * }
- * ]|
- *
- * ## Controlled shutdown of live sources in applications
- *
- * Applications that record from a live source may want to stop recording
- * in a controlled way, so that the recording is stopped, but the data
- * already in the pipeline is processed to the end (remember that many live
- * sources would go on recording forever otherwise). For that to happen the
- * application needs to make the source stop recording and send an EOS
- * event down the pipeline. The application would then wait for an
- * EOS message posted on the pipeline's bus to know when all data has
- * been processed and the pipeline can safely be stopped.
- *
- * An application may send an EOS event to a source element to make it
- * perform the EOS logic (send EOS event downstream or post a
- * %GST_MESSAGE_SEGMENT_DONE on the bus). This can typically be done
- * with the gst_element_send_event() function on the element or its parent bin.
- *
- * After the EOS has been sent to the element, the application should wait for
- * an EOS message to be posted on the pipeline's bus. Once this EOS message is
- * received, it may safely shut down the entire pipeline.
- */
 export declare class BaseSrc extends Gst.Element {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gstbase/base-src.js

@@ -1,6 +1,7 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * This is a generic base class for source elements. The following
@@ -116,6 +117,12 @@ import * as Gst from "../gst/index.js";
  * an EOS message to be posted on the pipeline's bus. Once this EOS message is
  * received, it may safely shut down the entire pipeline.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class BaseSrc extends Gst.Element {
     static glibTypeName = "GstBaseSrc";
     static objectType = "gobject";
@@ -613,13 +620,25 @@ export class BaseSrc extends Gst.Element {
         ], { type: "int", size: 32, unsigned: false });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gstbase/base-transform.d.ts

@@ -1,112 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
-/**
- * This base class is for filter elements that process data. Elements
- * that are suitable for implementation using #GstBaseTransform are ones
- * where the size and caps of the output is known entirely from the input
- * caps and buffer sizes. These include elements that directly transform
- * one buffer into another, modify the contents of a buffer in-place, as
- * well as elements that collate multiple input buffers into one output buffer,
- * or that expand one input buffer into multiple output buffers. See below
- * for more concrete use cases.
- *
- * It provides for:
- *
- * * one sinkpad and one srcpad
- * * Possible formats on sink and source pad implemented
- * with custom transform_caps function. By default uses
- * same format on sink and source.
- *
- * * Handles state changes
- * * Does flushing
- * * Push mode
- * * Pull mode if the sub-class transform can operate on arbitrary data
- *
- * # Use Cases
- *
- * ## Passthrough mode
- *
- * * Element has no interest in modifying the buffer. It may want to inspect it,
- * in which case the element should have a transform_ip function. If there
- * is no transform_ip function in passthrough mode, the buffer is pushed
- * intact.
- *
- * * The #GstBaseTransformClass.passthrough_on_same_caps variable
- * will automatically set/unset passthrough based on whether the
- * element negotiates the same caps on both pads.
- *
- * * #GstBaseTransformClass.passthrough_on_same_caps on an element that
- * doesn't implement a transform_caps function is useful for elements that
- * only inspect data (such as level)
- *
- * * Example elements
- *
- * * Level
- * * Videoscale, audioconvert, videoconvert, audioresample in certain modes.
- *
- * ## Modifications in-place - input buffer and output buffer are the same thing.
- *
- * * The element must implement a transform_ip function.
- * * Output buffer size must <= input buffer size
- * * If the always_in_place flag is set, non-writable buffers will be copied
- * and passed to the transform_ip function, otherwise a new buffer will be
- * created and the transform function called.
- *
- * * Incoming writable buffers will be passed to the transform_ip function
- * immediately.
- * * only implementing transform_ip and not transform implies always_in_place = %TRUE
- *
- * * Example elements:
- * * Volume
- * * Audioconvert in certain modes (signed/unsigned conversion)
- * * videoconvert in certain modes (endianness swapping)
- *
- * ## Modifications only to the caps/metadata of a buffer
- *
- * * The element does not require writable data, but non-writable buffers
- * should be subbuffered so that the meta-information can be replaced.
- *
- * * Elements wishing to operate in this mode should replace the
- * prepare_output_buffer method to create subbuffers of the input buffer
- * and set always_in_place to %TRUE
- *
- * * Example elements
- * * Capsfilter when setting caps on outgoing buffers that have
- * none.
- * * identity when it is going to re-timestamp buffers by
- * datarate.
- *
- * ## Normal mode
- * * always_in_place flag is not set, or there is no transform_ip function
- * * Element will receive an input buffer and output buffer to operate on.
- * * Output buffer is allocated by calling the prepare_output_buffer function.
- * * Example elements:
- * * Videoscale, videoconvert, audioconvert when doing
- * scaling/conversions
- *
- * ## Special output buffer allocations
- * * Elements which need to do special allocation of their output buffers
- * beyond allocating output buffers via the negotiated allocator or
- * buffer pool should implement the prepare_output_buffer method.
- *
- * * Example elements:
- * * efence
- *
- * # Sub-class settable flags on GstBaseTransform
- *
- * * passthrough
- *
- * * Implies that in the current configuration, the sub-class is not interested in modifying the buffers.
- * * Elements which are always in passthrough mode whenever the same caps has been negotiated on both pads can set the class variable passthrough_on_same_caps to have this behaviour automatically.
- *
- * * always_in_place
- * * Determines whether a non-writable buffer will be copied before passing
- * to the transform_ip function.
- *
- * * Implied %TRUE if no transform function is implemented.
- * * Implied %FALSE if ONLY transform function is implemented.
- */
 export declare class BaseTransform extends Gst.Element {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gstbase/base-transform.js

@@ -1,6 +1,7 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * This base class is for filter elements that process data. Elements
@@ -108,6 +109,12 @@ import * as Gst from "../gst/index.js";
  * * Implied %TRUE if no transform function is implemented.
  * * Implied %FALSE if ONLY transform function is implemented.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class BaseTransform extends Gst.Element {
     static glibTypeName = "GstBaseTransform";
     static objectType = "gobject";
@@ -410,13 +417,25 @@ export class BaseTransform extends Gst.Element {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gstbase/collect-pads.d.ts

@@ -1,44 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
-/**
- * Manages a set of pads that operate in collect mode. This means that control
- * is given to the manager of this object when all pads have data.
- *
- * * Collectpads are created with gst_collect_pads_new(). A callback should then
- * be installed with gst_collect_pads_set_function ().
- *
- * * Pads are added to the collection with gst_collect_pads_add_pad()/
- * gst_collect_pads_remove_pad(). The pad has to be a sinkpad. When added,
- * the chain, event and query functions of the pad are overridden. The
- * element_private of the pad is used to store private information for the
- * collectpads.
- *
- * * For each pad, data is queued in the _chain function or by
- * performing a pull_range.
- *
- * * When data is queued on all pads in waiting mode, the callback function is called.
- *
- * * Data can be dequeued from the pad with the gst_collect_pads_pop() method.
- * One can peek at the data with the gst_collect_pads_peek() function.
- * These functions will return %NULL if the pad received an EOS event. When all
- * pads return %NULL from a gst_collect_pads_peek(), the element can emit an EOS
- * event itself.
- *
- * * Data can also be dequeued in byte units using the gst_collect_pads_available(),
- * gst_collect_pads_read_buffer() and gst_collect_pads_flush() calls.
- *
- * * Elements should call gst_collect_pads_start() and gst_collect_pads_stop() in
- * their state change functions to start and stop the processing of the collectpads.
- * The gst_collect_pads_stop() call should be called before calling the parent
- * element state change function in the PAUSED_TO_READY state change to ensure
- * no pad is blocked and the element can finish streaming.
- *
- * * gst_collect_pads_set_waiting() sets a pad to waiting or non-waiting mode.
- * CollectPads element is not waiting for data to be collected on non-waiting pads.
- * Thus these pads may but need not have data when the callback is called.
- * All pads are in waiting mode by default.
- */
 export declare class CollectPads extends Gst.GstObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gstbase/collect-pads.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * Manages a set of pads that operate in collect mode. This means that control
@@ -41,6 +42,12 @@ import * as Gst from "../gst/index.js";
  * Thus these pads may but need not have data when the callback is called.
  * All pads are in waiting mode by default.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class CollectPads extends Gst.GstObject {
     static glibTypeName = "GstCollectPads";
     static objectType = "gobject";
@@ -490,13 +497,25 @@ export class CollectPads extends Gst.GstObject {
         return getNativeObject(ptr, Gst.Buffer);
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gstbase/data-queue.js

@@ -11,6 +11,10 @@ import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
     empty: { params: [], returnType: { type: "undefined" } },
     full: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class DataQueue extends GObject.GObject {
     static glibTypeName = "GstDataQueue";
@@ -50,6 +54,9 @@ export class DataQueue extends GObject.GObject {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gstbase/push-src.d.ts

@@ -1,26 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { BaseSrc } from "./base-src.js";
-/**
- * This class is mostly useful for elements that cannot do
- * random access, or at least very slowly. The source usually
- * prefers to push out a fixed size buffer.
- *
- * Subclasses usually operate in a format that is different from the
- * default GST_FORMAT_BYTES format of #GstBaseSrc.
- *
- * Classes extending this base class will usually be scheduled
- * in a push based mode. If the peer accepts to operate without
- * offsets and within the limits of the allowed block size, this
- * class can operate in getrange based mode automatically. To make
- * this possible, the subclass should implement and override the
- * SCHEDULING query.
- *
- * The subclass should extend the methods from the baseclass in
- * addition to the ::create method.
- *
- * Seeking, flushing, scheduling and sync is all handled by this
- * base class.
- */
 export declare class PushSrc extends BaseSrc {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gstbase/push-src.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { BaseSrc } from "./base-src.js";
 /**
  * This class is mostly useful for elements that cannot do
@@ -24,6 +25,12 @@ import { BaseSrc } from "./base-src.js";
  * Seeking, flushing, scheduling and sync is all handled by this
  * base class.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PushSrc extends BaseSrc {
     static glibTypeName = "GstPushSrc";
     static objectType = "gobject";
@@ -49,13 +56,25 @@ export class PushSrc extends BaseSrc {
         }
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gtk/about-dialog.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Window } from "./window.js";
 /**
@@ -107,6 +108,10 @@ const SIGNAL_META = {
     },
     unmap: { params: [], returnType: { type: "undefined" } },
     unrealize: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class AboutDialog extends Window {
     static glibTypeName = "GtkAboutDialog";
@@ -656,6 +661,9 @@ export class AboutDialog extends Window {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gtk/action-bar.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 /**
  * Presents contextual actions.
@@ -80,6 +81,10 @@ const SIGNAL_META = {
     },
     unmap: { params: [], returnType: { type: "undefined" } },
     unrealize: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class ActionBar extends Widget {
     static glibTypeName = "GtkActionBar";
@@ -229,6 +234,9 @@ export class ActionBar extends Widget {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gtk/activate-action.d.ts

@@ -1,10 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { ShortcutAction } from "./shortcut-action.js";
-/**
- * Activates a widget.
- *
- * Widgets are activated by calling {@link Gtk.Widget.activate}.
- */
 export declare class ActivateAction extends ShortcutAction {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/activate-action.js

@@ -2,12 +2,19 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { ShortcutAction } from "./shortcut-action.js";
 /**
  * Activates a widget.
  *
  * Widgets are activated by calling {@link Gtk.Widget.activate}.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ActivateAction extends ShortcutAction {
     static glibTypeName = "GtkActivateAction";
     static objectType = "gobject";
@@ -46,13 +53,25 @@ export class ActivateAction extends ShortcutAction {
         return getNativeObject(ptr, ActivateAction);
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [

package/dist/generated/gtk/adjustment.js

@@ -19,6 +19,10 @@ import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
     changed: { params: [], returnType: { type: "undefined" } },
     "value-changed": { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Adjustment extends GObject.InitiallyUnowned {
     static glibTypeName = "GtkAdjustment";
@@ -372,6 +376,9 @@ export class Adjustment extends GObject.InitiallyUnowned {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);