@gtkx/ffi 0.10.0 → 0.10.1

package/dist/generated/gtk/label.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 Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -270,6 +271,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 Label extends Widget {
     static glibTypeName = "GtkLabel";
@@ -1336,6 +1341,9 @@ export class Label 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/layout-child.d.ts

@@ -1,16 +1,6 @@
 import { LayoutManager } from "./layout-manager.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
-/**
- * The base class for objects that are meant to hold layout properties.
- *
- * If a `GtkLayoutManager` has per-child properties, like their packing type,
- * or the horizontal and vertical span, or the icon name, then the layout
- * manager should use a `GtkLayoutChild` implementation to store those properties.
- *
- * A `GtkLayoutChild` instance is only ever valid while a widget is part
- * of a layout.
- */
 export declare class LayoutChild extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/layout-child.js

@@ -12,6 +12,12 @@ import * as GObject from "../gobject/index.js";
  * A `GtkLayoutChild` instance is only ever valid while a widget is part
  * of a layout.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class LayoutChild extends GObject.GObject {
     static glibTypeName = "GtkLayoutChild";
     static objectType = "gobject";
@@ -44,13 +50,25 @@ export class LayoutChild extends GObject.GObject {
         return getNativeObject(ptr);
     }
     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/layout-manager.d.ts

@@ -3,55 +3,6 @@ import { Orientation, SizeRequestMode } from "./enums.js";
 import { LayoutChild } from "./layout-child.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Handles the preferred size and allocation for children of a widget.
- *
- * You typically subclass `GtkLayoutManager` if you want to implement a
- * layout policy for the children of a widget, or if you want to determine
- * the size of a widget depending on its contents.
- *
- * Each `GtkWidget` can only have a `GtkLayoutManager` instance associated
- * to it at any given time; it is possible, though, to replace the layout
- * manager instance using {@link Gtk.Widget.set_layout_manager}.
- *
- * ## Layout properties
- *
- * A layout manager can expose properties for controlling the layout of
- * each child, by creating an object type derived from {@link Gtk.LayoutChild}
- * and installing the properties on it as normal `GObject` properties.
- *
- * Each `GtkLayoutChild` instance storing the layout properties for a
- * specific child is created through the {@link Gtk.LayoutManager.get_layout_child}
- * method; a `GtkLayoutManager` controls the creation of its `GtkLayoutChild`
- * instances by overriding the GtkLayoutManagerClass.create_layout_child()
- * virtual function. The typical implementation should look like:
- *
- * ```c
- * static GtkLayoutChild *
- * create_layout_child (GtkLayoutManager *manager,
- *                      GtkWidget        *container,
- *                      GtkWidget        *child)
- * {
- *   return g_object_new (your_layout_child_get_type (),
- *                        "layout-manager", manager,
- *                        "child-widget", child,
- *                        NULL);
- * }
- * ```
- *
- * The {@link Gtk.LayoutChild.layout-manager} and
- * {@link Gtk.LayoutChild.child-widget} properties
- * on the newly created `GtkLayoutChild` instance are mandatory. The
- * `GtkLayoutManager` will cache the newly created `GtkLayoutChild` instance
- * until the widget is removed from its parent, or the parent removes the
- * layout manager.
- *
- * Each `GtkLayoutManager` instance creating a `GtkLayoutChild` should use
- * {@link Gtk.LayoutManager.get_layout_child} every time it needs to query
- * the layout properties; each `GtkLayoutChild` instance should call
- * {@link Gtk.LayoutManager.layout_changed} every time a property is
- * updated, in order to queue a new size measuring and allocation.
- */
 export declare class LayoutManager extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/layout-manager.js

@@ -51,6 +51,12 @@ import * as GObject from "../gobject/index.js";
  * {@link Gtk.LayoutManager.layout_changed} every time a property is
  * updated, in order to queue a new size measuring and allocation.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class LayoutManager extends GObject.GObject {
     static glibTypeName = "GtkLayoutManager";
     static objectType = "gobject";
@@ -220,13 +226,25 @@ export class LayoutManager extends GObject.GObject {
         ], { type: "undefined" });
     }
     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/level-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";
 /**
  * Shows a level indicator.
@@ -143,6 +144,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 LevelBar extends Widget {
     static glibTypeName = "GtkLevelBar";
@@ -437,6 +442,9 @@ export class LevelBar 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/link-button.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 { Button } from "./button.js";
 /**
  * A button with a hyperlink.
@@ -84,6 +85,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 LinkButton extends Button {
     static glibTypeName = "GtkLinkButton";
@@ -206,6 +211,9 @@ export class LinkButton extends Button {
                 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/list-base.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 { Widget } from "./widget.js";
 /**
  * The abstract base class for GTK's list widgets.
@@ -85,6 +86,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 ListBase extends Widget {
     static glibTypeName = "GtkListBase";
@@ -282,6 +287,9 @@ export class ListBase 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/list-box-row.js

@@ -3,6 +3,7 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 /**
  * The kind of widget that can be added to a `GtkListBox`.
@@ -48,6 +49,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 ListBoxRow extends Widget {
     static glibTypeName = "GtkListBoxRow";
@@ -370,6 +375,9 @@ export class ListBoxRow 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/list-box.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";
 /**
  * Shows a vertical list.
@@ -128,6 +129,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 ListBox extends Widget {
     static glibTypeName = "GtkListBox";
@@ -643,6 +648,9 @@ export class ListBox 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/list-header.d.ts

@@ -1,12 +1,5 @@
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Used by list widgets to represent the headers they display.
- *
- * `GtkListHeader` objects are managed just like {@link Gtk.ListItem}
- * objects via their factory, but provide a different set of properties suitable
- * for managing the header instead of individual items.
- */
 export declare class ListHeader extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/list-header.js

@@ -10,6 +10,12 @@ import * as GObject from "../gobject/index.js";
  * objects via their factory, but provide a different set of properties suitable
  * for managing the header instead of individual items.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ListHeader extends GObject.GObject {
     static glibTypeName = "GtkListHeader";
     static objectType = "gobject";
@@ -130,13 +136,25 @@ export class ListHeader extends GObject.GObject {
         ], { type: "undefined" });
     }
     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/list-item-factory.d.ts

@@ -1,53 +1,4 @@
 import * as GObject from "../gobject/index.js";
-/**
- * Creates widgets for the items taken from a `GListModel`.
- *
- * This is one of the core concepts of handling list widgets such
- * as {@link Gtk.ListView} or {@link Gtk.GridView}.
- *
- * The `GtkListItemFactory` is tasked with creating widgets for items
- * taken from the model when the views need them and updating them as
- * the items displayed by the view change.
- *
- * A view is usually only able to display anything after both a factory
- * and a model have been set on the view. So it is important that you do
- * not skip this step when setting up your first view.
- *
- * Because views do not display the whole list at once but only a few
- * items, they only need to maintain a few widgets at a time. They will
- * instruct the `GtkListItemFactory` to create these widgets and bind them
- * to the items that are currently displayed.
- *
- * As the list model changes or the user scrolls to the list, the items will
- * change and the view will instruct the factory to bind the widgets to those
- * new items.
- *
- * The actual widgets used for displaying those widgets is provided by you.
- *
- * When the factory needs widgets created, it will create a `GtkListItem`
- * and hand it to your code to set up a widget for. This list item will provide
- * various properties with information about what item to display and provide
- * you with some opportunities to configure its behavior. See the
- * {@link Gtk.ListItem} documentation for further details.
- *
- * Various implementations of `GtkListItemFactory` exist to allow you different
- * ways to provide those widgets. The most common implementations are
- * {@link Gtk.BuilderListItemFactory} which takes a `GtkBuilder` .ui file
- * and then creates widgets and manages everything automatically from the
- * information in that file and {@link Gtk.SignalListItemFactory} which allows
- * you to connect to signals with your own code and retain full control over
- * how the widgets are setup and managed.
- *
- * A `GtkListItemFactory` is supposed to be final - that means its behavior should
- * not change and the first widget created from it should behave the same way as
- * the last widget created from it.
- * If you intend to do changes to the behavior, it is recommended that you create
- * a new `GtkListItemFactory` which will allow the views to recreate its widgets.
- *
- * Once you have chosen your factory and created it, you need to set it on the view
- * widget you want to use it with, such as via {@link Gtk.ListView.set_factory}.
- * Reusing factories across different views is allowed, but very uncommon.
- */
 export declare class ListItemFactory extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/list-item-factory.js

@@ -52,6 +52,12 @@ import * as GObject from "../gobject/index.js";
  * widget you want to use it with, such as via {@link Gtk.ListView.set_factory}.
  * Reusing factories across different views is allowed, but very uncommon.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ListItemFactory extends GObject.GObject {
     static glibTypeName = "GtkListItemFactory";
     static objectType = "gobject";
@@ -73,13 +79,25 @@ export class ListItemFactory extends GObject.GObject {
         }
     }
     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/list-item.d.ts

@@ -1,21 +1,5 @@
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Used by list widgets to represent items in a {@link Gio.ListModel}.
- *
- * `GtkListItem` objects are managed by the list widget (with its factory)
- * and cannot be created by applications, but they need to be populated
- * by application code. This is done by calling {@link Gtk.ListItem.set_child}.
- *
- * `GtkListItem` objects exist in 2 stages:
- *
- * 1. The unbound stage where the listitem is not currently connected to
- * an item in the list. In that case, the {@link Gtk.ListItem.item}
- * property is set to `NULL`.
- *
- * 2. The bound stage where the listitem references an item from the list.
- * The {@link Gtk.ListItem.item} property is not `NULL`.
- */
 export declare class ListItem extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/list-item.js

@@ -19,6 +19,12 @@ import * as GObject from "../gobject/index.js";
  * 2. The bound stage where the listitem references an item from the list.
  * The {@link Gtk.ListItem.item} property is not `NULL`.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ListItem extends GObject.GObject {
     static glibTypeName = "GtkListItem";
     static objectType = "gobject";
@@ -294,13 +300,25 @@ export class ListItem extends GObject.GObject {
         ], { type: "undefined" });
     }
     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/list-store.js

@@ -241,6 +241,10 @@ const SIGNAL_META = {
         returnType: { type: "undefined" },
     },
     "sort-column-changed": { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class ListStore extends GObject.GObject {
     static glibTypeName = "GtkListStore";
@@ -1799,6 +1803,9 @@ export class ListStore 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);
+                }
                 if (t?.type === "boxed" && callbackArgs[i] != null) {
                     const cls = getNativeClass(t.innerType);
                     return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];

package/dist/generated/gtk/list-view.js

@@ -3,6 +3,7 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import { SelectionModel } from "./selection-model.js";
+import * as GObject from "../gobject/index.js";
 import { ListBase } from "./list-base.js";
 /**
  * Presents a large dynamic list of items.
@@ -151,6 +152,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 ListView extends ListBase {
     static glibTypeName = "GtkListView";
@@ -457,6 +462,9 @@ export class ListView extends ListBase {
                 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/lock-button.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 { Button } from "./button.js";
 /**
  * `GtkLockButton` is a widget to obtain and revoke authorizations
@@ -81,6 +82,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 LockButton extends Button {
     static glibTypeName = "GtkLockButton";
@@ -153,6 +158,9 @@ export class LockButton extends Button {
                 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/media-controls.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";
 /**
  * Shows controls for video playback.
@@ -47,6 +48,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 MediaControls extends Widget {
     static glibTypeName = "GtkMediaControls";
@@ -119,6 +124,9 @@ export class MediaControls 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);