@gtkx/ffi 0.10.0 → 0.10.1

package/dist/generated/gdk/memory-texture-builder.js

@@ -19,6 +19,12 @@ import * as cairo from "../cairo/index.js";
  * `GdkMemoryTextureBuilder` can be used for quick one-shot construction of
  * textures as well as kept around and reused to construct multiple textures.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MemoryTextureBuilder extends GObject.GObject {
     static glibTypeName = "GdkMemoryTextureBuilder";
     static objectType = "gobject";
@@ -431,13 +437,25 @@ export class MemoryTextureBuilder 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/gdk/memory-texture.js

@@ -2,11 +2,16 @@ 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 { Texture } from "./texture.js";
 /** A `GdkTexture` representing image data in memory. */
 const SIGNAL_META = {
     "invalidate-contents": { params: [], returnType: { type: "undefined" } },
     "invalidate-size": { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class MemoryTexture extends Texture {
     static glibTypeName = "GdkMemoryTexture";
@@ -76,6 +81,9 @@ export class MemoryTexture extends Texture {
                 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/gdk/monitor.js

@@ -13,6 +13,10 @@ import * as GObject from "../gobject/index.js";
  */
 const SIGNAL_META = {
     invalidate: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Monitor extends GObject.GObject {
     static glibTypeName = "GdkMonitor";
@@ -244,6 +248,9 @@ export class Monitor 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/gdk/seat.js

@@ -20,6 +20,10 @@ const SIGNAL_META = {
         params: [{ type: "gobject", borrowed: true }],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Seat extends GObject.GObject {
     static glibTypeName = "GdkSeat";
@@ -131,6 +135,9 @@ export class Seat 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/gdk/snapshot.d.ts

@@ -1,9 +1,4 @@
 import * as GObject from "../gobject/index.js";
-/**
- * Base type for snapshot operations.
- *
- * The subclass of `GdkSnapshot` used by GTK is GtkSnapshot.
- */
 export declare class Snapshot extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gdk/snapshot.js

@@ -7,6 +7,12 @@ import * as GObject from "../gobject/index.js";
  *
  * The subclass of `GdkSnapshot` used by GTK is GtkSnapshot.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class Snapshot extends GObject.GObject {
     static glibTypeName = "GdkSnapshot";
     static objectType = "gobject";
@@ -14,13 +20,25 @@ export class Snapshot extends GObject.GObject {
         super();
     }
     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/gdk/surface.js

@@ -48,6 +48,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "boolean" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Surface extends GObject.GObject {
     static glibTypeName = "GdkSurface";
@@ -664,6 +668,9 @@ export class Surface 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/gdk/texture.js

@@ -38,6 +38,10 @@ import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
     "invalidate-contents": { params: [], returnType: { type: "undefined" } },
     "invalidate-size": { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Texture extends GObject.GObject {
     static glibTypeName = "GdkTexture";
@@ -817,6 +821,9 @@ export class Texture 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/gdk/vulkan-context.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 { DrawContext } from "./draw-context.js";
 /**
  * Represents the platform-specific Vulkan draw context.
@@ -14,6 +15,10 @@ import { DrawContext } from "./draw-context.js";
  */
 const SIGNAL_META = {
     "images-updated": { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class VulkanContext extends DrawContext {
     static glibTypeName = "GdkVulkanContext";
@@ -35,6 +40,9 @@ export class VulkanContext extends DrawContext {
                 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/gdkpixbuf/pixbuf-animation-iter.d.ts

@@ -1,10 +1,6 @@
 import { Pixbuf } from "./pixbuf.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * An opaque object representing an iterator which points to a
- * certain position in an animation.
- */
 export declare class PixbufAnimationIter extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.js

@@ -7,6 +7,12 @@ import * as GObject from "../gobject/index.js";
  * An opaque object representing an iterator which points to a
  * certain position in an animation.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PixbufAnimationIter extends GObject.GObject {
     static glibTypeName = "GdkPixbufAnimationIter";
     static objectType = "gobject";
@@ -126,13 +132,25 @@ export class PixbufAnimationIter extends GObject.GObject {
         ], { 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("libgdk_pixbuf-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gdkpixbuf/pixbuf-animation.d.ts

@@ -3,21 +3,6 @@ import { PixbufAnimationIter } from "./pixbuf-animation-iter.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
-/**
- * An opaque object representing an animation.
- *
- * The GdkPixBuf library provides a simple mechanism to load and
- * represent animations. An animation is conceptually a series of
- * frames to be displayed over time.
- *
- * The animation may not be represented as a series of frames
- * internally; for example, it may be stored as a sprite and
- * instructions for moving the sprite around a background.
- *
- * To display an animation you don't need to understand its
- * representation, however; you just ask `GdkPixbuf` what should
- * be displayed at a given point in time.
- */
 export declare class PixbufAnimation extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gdkpixbuf/pixbuf-animation.js

@@ -19,6 +19,12 @@ import * as GObject from "../gobject/index.js";
  * representation, however; you just ask `GdkPixbuf` what should
  * be displayed at a given point in time.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PixbufAnimation extends GObject.GObject {
     static glibTypeName = "GdkPixbufAnimation";
     static objectType = "gobject";
@@ -305,13 +311,25 @@ export class PixbufAnimation extends GObject.GObject {
         ], { 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("libgdk_pixbuf-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gdkpixbuf/pixbuf-loader.js

@@ -71,6 +71,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class PixbufLoader extends GObject.GObject {
     static glibTypeName = "GdkPixbufLoader";
@@ -408,6 +412,9 @@ export class PixbufLoader 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/gdkpixbuf/pixbuf-non-anim.js

@@ -2,7 +2,14 @@ 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 { PixbufAnimation } from "./pixbuf-animation.js";
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PixbufNonAnim extends PixbufAnimation {
     static glibTypeName = "GdkPixbufNonAnim";
     static objectType = "gobject";
@@ -25,13 +32,25 @@ export class PixbufNonAnim extends PixbufAnimation {
         }
     }
     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("libgdk_pixbuf-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gdkpixbuf/pixbuf-simple-anim-iter.js

@@ -2,7 +2,14 @@ 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 { PixbufAnimationIter } from "./pixbuf-animation-iter.js";
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PixbufSimpleAnimIter extends PixbufAnimationIter {
     static glibTypeName = "GdkPixbufSimpleAnimIter";
     static objectType = "gobject";
@@ -24,13 +31,25 @@ export class PixbufSimpleAnimIter extends PixbufAnimationIter {
         }
     }
     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("libgdk_pixbuf-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gdkpixbuf/pixbuf-simple-anim.d.ts

@@ -1,7 +1,6 @@
 import { Pixbuf } from "./pixbuf.js";
 import * as GObject from "../gobject/index.js";
 import { PixbufAnimation } from "./pixbuf-animation.js";
-/** An opaque struct representing a simple animation. */
 export declare class PixbufSimpleAnim extends PixbufAnimation {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gdkpixbuf/pixbuf-simple-anim.js

@@ -2,8 +2,15 @@ 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 { PixbufAnimation } from "./pixbuf-animation.js";
 /** An opaque struct representing a simple animation. */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class PixbufSimpleAnim extends PixbufAnimation {
     static glibTypeName = "GdkPixbufSimpleAnim";
     static objectType = "gobject";
@@ -85,13 +92,25 @@ export class PixbufSimpleAnim extends PixbufAnimation {
         ], { 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("libgdk_pixbuf-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gdkpixbuf/pixbuf.d.ts

@@ -4,140 +4,6 @@ import { PixbufFormat } from "./pixbuf-format.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
-/**
- * A pixel buffer.
- *
- * `GdkPixbuf` contains information about an image's pixel data,
- * its color space, bits per sample, width and height, and the
- * rowstride (the number of bytes between the start of one row
- * and the start of the next).
- *
- * ## Creating new `GdkPixbuf`
- *
- * The most basic way to create a pixbuf is to wrap an existing pixel
- * buffer with a {@link GdkPixbuf.Pixbuf} instance. You can use the
- * [`ctor`GdkPixbuf`.Pixbuf.new_from_data`] function to do this.
- *
- * Every time you create a new `GdkPixbuf` instance for some data, you
- * will need to specify the destroy notification function that will be
- * called when the data buffer needs to be freed; this will happen when
- * a `GdkPixbuf` is finalized by the reference counting functions. If
- * you have a chunk of static data compiled into your application, you
- * can pass in `NULL` as the destroy notification function so that the
- * data will not be freed.
- *
- * The [`ctor`GdkPixbuf`.Pixbuf.new`] constructor function can be used
- * as a convenience to create a pixbuf with an empty buffer; this is
- * equivalent to allocating a data buffer using `malloc()` and then
- * wrapping it with `gdk_pixbuf_new_from_data()`. The `gdk_pixbuf_new()`
- * function will compute an optimal rowstride so that rendering can be
- * performed with an efficient algorithm.
- *
- * You can also copy an existing pixbuf with the {@link Pixbuf.copy}
- * function. This is not the same as just acquiring a reference to
- * the old pixbuf instance: the copy function will actually duplicate
- * the pixel data in memory and create a new {@link Pixbuf} instance
- * for it.
- *
- * ## Reference counting
- *
- * `GdkPixbuf` structures are reference counted. This means that an
- * application can share a single pixbuf among many parts of the
- * code. When a piece of the program needs to use a pixbuf, it should
- * acquire a reference to it by calling `g_object_ref()`; when it no
- * longer needs the pixbuf, it should release the reference it acquired
- * by calling `g_object_unref()`. The resources associated with a
- * `GdkPixbuf` will be freed when its reference count drops to zero.
- * Newly-created `GdkPixbuf` instances start with a reference count
- * of one.
- *
- * ## Image Data
- *
- * Image data in a pixbuf is stored in memory in an uncompressed,
- * packed format. Rows in the image are stored top to bottom, and
- * in each row pixels are stored from left to right.
- *
- * There may be padding at the end of a row.
- *
- * The "rowstride" value of a pixbuf, as returned by [`method`GdkPixbuf`.Pixbuf.get_rowstride`],
- * indicates the number of bytes between rows.
- *
- * **NOTE**: If you are copying raw pixbuf data with `memcpy()` note that the
- * last row in the pixbuf may not be as wide as the full rowstride, but rather
- * just as wide as the pixel data needs to be; that is: it is unsafe to do
- * `memcpy (dest, pixels, rowstride * height)` to copy a whole pixbuf. Use
- * {@link GdkPixbuf.Pixbuf.copy} instead, or compute the width in bytes of the
- * last row as:
- *
- * ```c
- * last_row = width * ((n_channels * bits_per_sample + 7) / 8);
- * ```
- *
- * The same rule applies when iterating over each row of a `GdkPixbuf` pixels
- * array.
- *
- * The following code illustrates a simple `put_pixel()`
- * function for RGB pixbufs with 8 bits per channel with an alpha
- * channel.
- *
- * ```c
- * static void
- * put_pixel (GdkPixbuf *pixbuf,
- *            int x,
- * 	   int y,
- * 	   guchar red,
- * 	   guchar green,
- * 	   guchar blue,
- * 	   guchar alpha)
- * {
- *   int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
- *
- *   // Ensure that the pixbuf is valid
- *   g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
- *   g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
- *   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
- *   g_assert (n_channels == 4);
- *
- *   int width = gdk_pixbuf_get_width (pixbuf);
- *   int height = gdk_pixbuf_get_height (pixbuf);
- *
- *   // Ensure that the coordinates are in a valid range
- *   g_assert (x >= 0 && x < width);
- *   g_assert (y >= 0 && y < height);
- *
- *   int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
- *
- *   // The pixel buffer in the GdkPixbuf instance
- *   guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
- *
- *   // The pixel we wish to modify
- *   guchar *p = pixels + y * rowstride + x * n_channels;
- *   p[0] = red;
- *   p[1] = green;
- *   p[2] = blue;
- *   p[3] = alpha;
- * }
- * ```
- *
- * ## Loading images
- *
- * The `GdkPixBuf` class provides a simple mechanism for loading
- * an image from a file in synchronous and asynchronous fashion.
- *
- * For GUI applications, it is recommended to use the asynchronous
- * stream API to avoid blocking the control flow of the application.
- *
- * Additionally, `GdkPixbuf` provides the {@link GdkPixbuf.PixbufLoader`}
- * API for progressive image loading.
- *
- * ## Saving images
- *
- * The `GdkPixbuf` class provides methods for saving image data in
- * a number of file formats. The formatted data can be written to a
- * file or to a memory buffer. `GdkPixbuf` can also call a user-defined
- * callback on the data, which allows to e.g. write the image
- * to a socket or store it in a database.
- */
 export declare class Pixbuf extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";