@gtkx/ffi 0.6.1 → 0.7.0

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

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, NativeError, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 /**
  * An opaque object representing an animation.
@@ -54,12 +54,27 @@ export class PixbufAnimation extends GObject.GObject {
      * @param resourcePath - the path of the resource file
      */
     static animationNewFromResource(resourcePath) {
+        const error = { value: null };
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_resource", [
             {
                 type: { type: "string" },
                 value: resourcePath,
             },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
         ], { type: "gobject", borrowed: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
         return getObject(ptr);
     }
     /**
@@ -79,6 +94,7 @@ export class PixbufAnimation extends GObject.GObject {
      * @param cancellable - optional `GCancellable` object
      */
     static animationNewFromStream(stream, cancellable) {
+        const error = { value: null };
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_stream", [
             {
                 type: { type: "gobject", borrowed: true },
@@ -89,7 +105,21 @@ export class PixbufAnimation extends GObject.GObject {
                 value: cancellable?.id ?? cancellable,
                 optional: true,
             },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
         ], { type: "gobject", borrowed: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
         return getObject(ptr);
     }
     /**
@@ -98,12 +128,27 @@ export class PixbufAnimation extends GObject.GObject {
      * @param asyncResult - a #GAsyncResult
      */
     static animationNewFromStreamFinish(asyncResult) {
+        const error = { value: null };
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_stream_finish", [
             {
                 type: { type: "gobject", borrowed: true },
                 value: asyncResult?.id ?? asyncResult,
             },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
         ], { type: "gobject", borrowed: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
         return getObject(ptr);
     }
     /**

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

@@ -1,5 +1,5 @@
 import { alloc, read, write } from "@gtkx/native";
-import { call, getObject, registerType } from "@gtkx/ffi";
+import { call, getBoxed, registerType } from "@gtkx/ffi";
 /**
  * A `GdkPixbufFormat` contains information about the image format accepted
  * by a module.
@@ -43,7 +43,7 @@ export class PixbufFormat {
         });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getBoxed(ptr, "GdkPixbufFormat");
     }
     /**
      * Frees the resources allocated when copying a `GdkPixbufFormat`

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

@@ -1,4 +1,4 @@
-import { call, NativeError, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, NativeError, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 /**
  * Incremental image loader.
@@ -107,12 +107,27 @@ export class PixbufLoader extends GObject.GObject {
      * @param mimeType - the mime type to be loaded
      */
     static loaderNewWithMimeType(mimeType) {
+        const error = { value: null };
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_new_with_mime_type", [
             {
                 type: { type: "string" },
                 value: mimeType,
             },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
         ], { type: "gobject", borrowed: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
         return getObject(ptr);
     }
     /**
@@ -133,12 +148,27 @@ export class PixbufLoader extends GObject.GObject {
      * @param imageType - name of the image format to be loaded with the image
      */
     static loaderNewWithType(imageType) {
+        const error = { value: null };
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_new_with_type", [
             {
                 type: { type: "string" },
                 value: imageType,
             },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
         ], { type: "gobject", borrowed: false });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
         return getObject(ptr);
     }
     /**
@@ -221,7 +251,7 @@ export class PixbufLoader extends GObject.GObject {
         });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getBoxed(ptr, "GdkPixbufFormat");
     }
     /**
      * Queries the #GdkPixbuf that a pixbuf loader is currently creating.

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

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { Colorspace, InterpType, PixbufRotation } from "./enums.js";
 import { PixbufFormat } from "./pixbuf-format.js";
+import * as AppStream from "../appstream/index.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
@@ -905,6 +906,66 @@ export declare class Pixbuf extends GObject.GObject {
      * @param value - a nul-terminated string.
      */
     setOption(key: string, value: string): boolean;
+    /**
+     * Checks if two icons are equal.
+     * @param icon2 - pointer to the second #GIcon.
+     */
+    equal(icon2?: AppStream.Icon | null): boolean;
+    /**
+     * Gets a hash for an icon.
+     */
+    hash(): number;
+    /**
+     * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+     * back by calling g_icon_deserialize() on the returned value.
+     * As serialization will avoid using raw icon data when possible, it only
+     * makes sense to transfer the #GVariant between processes on the same machine,
+     * (as opposed to over the network), and within the same file system namespace.
+     */
+    serialize(): GLib.Variant | null;
+    /**
+     * Generates a textual representation of `icon` that can be used for
+     * serialization such as when passing `icon` to a different process or
+     * saving it to persistent storage. Use g_icon_new_for_string() to
+     * get `icon` back from the returned string.
+     *
+     * The encoding of the returned string is proprietary to #GIcon except
+     * in the following two cases
+     *
+     * - If `icon` is a #GFileIcon, the returned string is a native path
+     * (such as `/path/to/my icon.png`) without escaping
+     * if the #GFile for `icon` is a native file.  If the file is not
+     * native, the returned string is the result of g_file_get_uri()
+     * (such as `sftp://path/to/my%20icon.png`).
+     *
+     * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+     * the encoding is simply the name (such as `network-server`).
+     */
+    toString(): string | null;
+    /**
+     * Loads a loadable icon. For the asynchronous version of this function,
+     * see g_loadable_icon_load_async().
+     * @param size - an integer.
+     * @param type - a location to store the type of the loaded
+     * @param cancellable - optional #GCancellable object, %NULL to
+     */
+    load(size: number, type?: Ref<string> | null, cancellable?: Gio.Cancellable | null): Gio.InputStream;
+    /**
+     * Loads an icon asynchronously. To finish this function, see
+     * g_loadable_icon_load_finish(). For the synchronous, blocking
+     * version of this function, see g_loadable_icon_load().
+     * @param size - an integer.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
+    loadAsync(size: number, cancellable?: Gio.Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+     * @param res - a #GAsyncResult.
+     * @param type - a location to store the type of the loaded
+     */
+    loadFinish(res: Gio.AsyncResult, type?: Ref<string> | null): Gio.InputStream;
     connect(signal: "notify", handler: (self: Pixbuf, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }