@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gdk/functions.js

@@ -5,6 +5,35 @@ import { ContentFormats } from "./content-formats.js";
 import { Paintable } from "./paintable.js";
 import * as GdkPixbuf from "../gdkpixbuf/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Draws GL content onto a cairo context.
+ *
+ * It takes a render buffer ID (`source_type` == GL_RENDERBUFFER) or a texture
+ * id (`source_type` == GL_TEXTURE) and draws it onto `cr` with an OVER operation,
+ * respecting the current clip. The top left corner of the rectangle specified
+ * by @x, @y, `width` and `height` will be drawn at the current (0,0) position of
+ * the `cairo_t`.
+ *
+ * This will work for *all* `cairo_t`, as long as `surface` is realized, but the
+ * fallback implementation that reads back the pixels from the buffer may be
+ * used in the general case. In the case of direct drawing to a surface with
+ * no special effects applied to `cr` it will however use a more efficient
+ * approach.
+ *
+ * For GL_RENDERBUFFER the code will always fall back to software for buffers
+ * with alpha components, so make sure you use GL_TEXTURE if using alpha.
+ *
+ * Calling this may change the current GL context.
+ * @param cr - a cairo context
+ * @param surface - The surface we're rendering for (not necessarily into)
+ * @param source - The GL ID of the source buffer
+ * @param sourceType - The type of the @source
+ * @param bufferScale - The scale-factor that the `source` buffer is allocated for
+ * @param x - The source x position in `source` to start copying from in GL coordinates
+ * @param y - The source y position in `source` to start copying from in GL coordinates
+ * @param width - The width of the region to draw
+ * @param height - The height of the region to draw
+ */
 export const cairoDrawFromGl = (cr, surface, source, sourceType, bufferScale, x, y, width, height) => {
     call("libgtk-4.so.1", "gdk_cairo_draw_from_gl", [
         {
@@ -50,6 +79,11 @@ export const cairoDrawFromGl = (cr, surface, source, sourceType, bufferScale, x,
         },
     ], { type: "undefined" });
 };
+/**
+ * Adds the given rectangle to the current path of @cr.
+ * @param cr - a cairo context
+ * @param rectangle - a `GdkRectangle`
+ */
 export const cairoRectangle = (cr, rectangle) => {
     call("libgtk-4.so.1", "gdk_cairo_rectangle", [
         {
@@ -72,6 +106,11 @@ export const cairoRectangle = (cr, rectangle) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Adds the given region to the current path of @cr.
+ * @param cr - a cairo context
+ * @param region - a `cairo_region_t`
+ */
 export const cairoRegion = (cr, region) => {
     call("libgtk-4.so.1", "gdk_cairo_region", [
         {
@@ -94,6 +133,14 @@ export const cairoRegion = (cr, region) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Creates region that covers the area where the given
+ * `surface` is more than 50% opaque.
+ *
+ * This function takes into account device offsets that might be
+ * set with cairo_surface_set_device_offset().
+ * @param surface - a cairo surface
+ */
 export const cairoRegionCreateFromSurface = (surface) => {
     const ptr = call("libgtk-4.so.1", "gdk_cairo_region_create_from_surface", [
         {
@@ -113,6 +160,16 @@ export const cairoRegionCreateFromSurface = (surface) => {
     });
     return getObject(ptr, cairo.Region);
 };
+/**
+ * Sets the given pixbuf as the source pattern for @cr.
+ *
+ * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
+ * so that the origin of `pixbuf` is @pixbuf_x, @pixbuf_y.
+ * @param cr - a cairo context
+ * @param pixbuf - a `GdkPixbuf`
+ * @param pixbufX - X coordinate of location to place upper left corner of @pixbuf
+ * @param pixbufY - Y coordinate of location to place upper left corner of @pixbuf
+ */
 export const cairoSetSourcePixbuf = (cr, pixbuf, pixbufX, pixbufY) => {
     call("libgtk-4.so.1", "gdk_cairo_set_source_pixbuf", [
         {
@@ -138,6 +195,11 @@ export const cairoSetSourcePixbuf = (cr, pixbuf, pixbufX, pixbufY) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Sets the specified `GdkRGBA` as the source color of @cr.
+ * @param cr - a cairo context
+ * @param rgba - a `GdkRGBA`
+ */
 export const cairoSetSourceRgba = (cr, rgba) => {
     call("libgtk-4.so.1", "gdk_cairo_set_source_rgba", [
         {
@@ -160,6 +222,11 @@ export const cairoSetSourceRgba = (cr, rgba) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the color state object representing the oklab color space.
+ *
+ * This is a perceptually uniform color state.
+ */
 export const colorStateGetOklab = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_oklab", [], {
         type: "boxed",
@@ -169,6 +236,12 @@ export const colorStateGetOklab = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Returns the color state object representing the oklch color space.
+ *
+ * This is the polar variant of oklab, in which the hue is encoded as
+ * a polar coordinate.
+ */
 export const colorStateGetOklch = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_oklch", [], {
         type: "boxed",
@@ -178,6 +251,17 @@ export const colorStateGetOklch = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Returns the color state object representing the linear rec2100 color space.
+ *
+ * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and a linear
+ * transfer function.
+ *
+ * It is equivalent to the Cicp tuple 9/8/0/1.
+ *
+ * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-linear)
+ * for details about this colorstate.
+ */
 export const colorStateGetRec2100Linear = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_rec2100_linear", [], {
         type: "boxed",
@@ -187,6 +271,17 @@ export const colorStateGetRec2100Linear = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Returns the color state object representing the rec2100-pq color space.
+ *
+ * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and the transfer
+ * function defined by SMPTE ST 2084 and BT.2100-2.
+ *
+ * It is equivalent to the Cicp tuple 9/16/0/1.
+ *
+ * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-pq)
+ * for details about this colorstate.
+ */
 export const colorStateGetRec2100Pq = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_rec2100_pq", [], {
         type: "boxed",
@@ -196,6 +291,17 @@ export const colorStateGetRec2100Pq = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Returns the color state object representing the sRGB color space.
+ *
+ * This color state uses the primaries defined by BT.709-6 and the transfer function
+ * defined by IEC 61966-2-1.
+ *
+ * It is equivalent to the Cicp tuple 1/13/0/1.
+ *
+ * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB)
+ * for details about this colorstate.
+ */
 export const colorStateGetSrgb = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_srgb", [], {
         type: "boxed",
@@ -205,6 +311,16 @@ export const colorStateGetSrgb = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Returns the color state object representing the linearized sRGB color space.
+ *
+ * This color state uses the primaries defined by BT.709-6 and a linear transfer function.
+ *
+ * It is equivalent to the Cicp tuple 1/8/0/1.
+ *
+ * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear)
+ * for details about this colorstate.
+ */
 export const colorStateGetSrgbLinear = () => {
     const ptr = call("libgtk-4.so.1", "gdk_color_state_get_srgb_linear", [], {
         type: "boxed",
@@ -214,6 +330,19 @@ export const colorStateGetSrgbLinear = () => {
     });
     return getObject(ptr, ColorState);
 };
+/**
+ * Reads content from the given input stream and deserialize it, asynchronously.
+ *
+ * The default I/O priority is `G_PRIORITY_DEFAULT` (i.e. 0), and lower numbers
+ * indicate a higher priority.
+ * @param stream - a `GInputStream` to read the serialized content from
+ * @param mimeType - the mime type to deserialize from
+ * @param type - the GType to deserialize from
+ * @param ioPriority - the I/O priority of the operation
+ * @param cancellable - optional `GCancellable` object
+ * @param callback - callback to call when the operation is done
+ * @param userData - data to pass to the callback function
+ */
 export const contentDeserializeAsync = (stream, mimeType, type, ioPriority, cancellable, callback) => {
     call("libgtk-4.so.1", "gdk_content_deserialize_async", [
         {
@@ -249,6 +378,11 @@ export const contentDeserializeAsync = (stream, mimeType, type, ioPriority, canc
         },
     ], { type: "undefined" });
 };
+/**
+ * Finishes a content deserialization operation.
+ * @param result - the `GAsyncResult`
+ * @param value - return location for the result of the operation
+ */
 export const contentDeserializeFinish = (result, value) => {
     const error = { value: null };
     const _result = call("libgtk-4.so.1", "gdk_content_deserialize_finish", [
@@ -284,6 +418,17 @@ export const contentDeserializeFinish = (result, value) => {
     }
     return _result;
 };
+/**
+ * Parses the given `string` into `GdkContentFormats` and
+ * returns the formats.
+ *
+ * Strings printed via [method@Gdk.ContentFormats.to_string]
+ * can be read in again successfully using this function.
+ *
+ * If `string` does not describe valid content formats, %NULL
+ * is returned.
+ * @param string - the string to parse
+ */
 export const contentFormatsParse = (string) => {
     const ptr = call("libgtk-4.so.1", "gdk_content_formats_parse", [
         {
@@ -300,6 +445,18 @@ export const contentFormatsParse = (string) => {
         return null;
     return getObject(ptr, ContentFormats);
 };
+/**
+ * Registers a function to deserialize object of a given type.
+ *
+ * Since 4.20, when looking up a deserializer to use, GTK will
+ * use the last registered deserializer for a given mime type,
+ * so applications can override the built-in deserializers.
+ * @param mimeType - the mime type which the function can deserialize from
+ * @param type - the type of objects that the function creates
+ * @param deserialize - the callback
+ * @param data - data that `deserialize` can access
+ * @param notify - destroy notify for @data
+ */
 export const contentRegisterDeserializer = (mimeType, type, deserialize, notify, data) => {
     call("libgtk-4.so.1", "gdk_content_register_deserializer", [
         {
@@ -325,6 +482,18 @@ export const contentRegisterDeserializer = (mimeType, type, deserialize, notify,
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers a function to serialize objects of a given type.
+ *
+ * Since 4.20, when looking up a serializer to use, GTK will
+ * use the last registered serializer for a given mime type,
+ * so applications can override the built-in serializers.
+ * @param type - the type of objects that the function can serialize
+ * @param mimeType - the mime type to serialize to
+ * @param serialize - the callback
+ * @param data - data that `serialize` can access
+ * @param notify - destroy notify for @data
+ */
 export const contentRegisterSerializer = (type, mimeType, serialize, notify, data) => {
     call("libgtk-4.so.1", "gdk_content_register_serializer", [
         {
@@ -350,6 +519,19 @@ export const contentRegisterSerializer = (type, mimeType, serialize, notify, dat
         },
     ], { type: "undefined" });
 };
+/**
+ * Serialize content and write it to the given output stream, asynchronously.
+ *
+ * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+ * indicate a higher priority.
+ * @param stream - a `GOutputStream` to write the serialized content to
+ * @param mimeType - the mime type to serialize to
+ * @param value - the content to serialize
+ * @param ioPriority - the I/O priority of the operation
+ * @param cancellable - optional `GCancellable` object
+ * @param callback - callback to call when the operation is done
+ * @param userData - data to pass to the callback function
+ */
 export const contentSerializeAsync = (stream, mimeType, value, ioPriority, cancellable, callback) => {
     call("libgtk-4.so.1", "gdk_content_serialize_async", [
         {
@@ -390,6 +572,10 @@ export const contentSerializeAsync = (stream, mimeType, value, ioPriority, cance
         },
     ], { type: "undefined" });
 };
+/**
+ * Finishes a content serialization operation.
+ * @param result - the `GAsyncResult`
+ */
 export const contentSerializeFinish = (result) => {
     const error = { value: null };
     const _result = call("libgtk-4.so.1", "gdk_content_serialize_finish", [
@@ -414,6 +600,9 @@ export const contentSerializeFinish = (result) => {
     }
     return _result;
 };
+/**
+ * Registers an error quark for [class@Gdk.DmabufTexture] errors.
+ */
 export const dmabufErrorQuark = () => {
     return call("libgtk-4.so.1", "gdk_dmabuf_error_quark", [], {
         type: "int",
@@ -421,6 +610,14 @@ export const dmabufErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Checks if `action` represents a single action or includes
+ * multiple actions.
+ *
+ * When `action` is `GDK_ACTION_NONE` - ie no action was given, `TRUE`
+ * is returned.
+ * @param action - a `GdkDragAction`
+ */
 export const dragActionIsUnique = (action) => {
     return call("libgtk-4.so.1", "gdk_drag_action_is_unique", [
         {
@@ -429,6 +626,19 @@ export const dragActionIsUnique = (action) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Returns the relative angle from `event1` to @event2.
+ *
+ * The relative angle is the angle between the X axis and the line
+ * through both events' positions. The rotation direction for positive
+ * angles is from the positive X axis towards the positive Y axis.
+ *
+ * This assumes that both events have X/Y information.
+ * If not, this function returns %FALSE.
+ * @param event1 - first `GdkEvent`
+ * @param event2 - second `GdkEvent`
+ * @param angle - return location for the relative angle between both events
+ */
 export const eventsGetAngle = (event1, event2, angle) => {
     return call("libgtk-4.so.1", "gdk_events_get_angle", [
         {
@@ -445,6 +655,16 @@ export const eventsGetAngle = (event1, event2, angle) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Returns the point halfway between the events' positions.
+ *
+ * This assumes that both events have X/Y information.
+ * If not, this function returns %FALSE.
+ * @param event1 - first `GdkEvent`
+ * @param event2 - second `GdkEvent`
+ * @param x - return location for the X coordinate of the center
+ * @param y - return location for the Y coordinate of the center
+ */
 export const eventsGetCenter = (event1, event2, x, y) => {
     return call("libgtk-4.so.1", "gdk_events_get_center", [
         {
@@ -465,6 +685,15 @@ export const eventsGetCenter = (event1, event2, x, y) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Returns the distance between the event locations.
+ *
+ * This assumes that both events have X/Y information.
+ * If not, this function returns %FALSE.
+ * @param event1 - first `GdkEvent`
+ * @param event2 - second `GdkEvent`
+ * @param distance - return location for the distance
+ */
 export const eventsGetDistance = (event1, event2, distance) => {
     return call("libgtk-4.so.1", "gdk_events_get_distance", [
         {
@@ -481,6 +710,9 @@ export const eventsGetDistance = (event1, event2, distance) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Registers an error quark for [class@Gdk.GLContext] errors.
+ */
 export const glErrorQuark = () => {
     return call("libgtk-4.so.1", "gdk_gl_error_quark", [], {
         type: "int",
@@ -488,6 +720,13 @@ export const glErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Canonicalizes the given mime type and interns the result.
+ *
+ * If `string` is not a valid mime type, %NULL is returned instead.
+ * See RFC 2048 for the syntax if mime types.
+ * @param string - string of a potential mime type
+ */
 export const internMimeType = (string) => {
     return call("libgtk-4.so.1", "gdk_intern_mime_type", [
         {
@@ -496,6 +735,14 @@ export const internMimeType = (string) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Obtains the upper- and lower-case versions of the keyval @symbol.
+ *
+ * Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.
+ * @param symbol - a keyval
+ * @param lower - return location for lowercase version of @symbol
+ * @param upper - return location for uppercase version of @symbol
+ */
 export const keyvalConvertCase = (symbol, lower, upper) => {
     call("libgtk-4.so.1", "gdk_keyval_convert_case", [
         {
@@ -518,6 +765,14 @@ export const keyvalConvertCase = (symbol, lower, upper) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Converts a key name to a key value.
+ *
+ * The names are the same as those in the
+ * `gdk/gdkkeysyms.h` header file
+ * but without the leading “GDK_KEY_”.
+ * @param keyvalName - a key name
+ */
 export const keyvalFromName = (keyvalName) => {
     return call("libgtk-4.so.1", "gdk_keyval_from_name", [
         {
@@ -526,6 +781,10 @@ export const keyvalFromName = (keyvalName) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Returns true if the given key value is in lower case.
+ * @param keyval - a key value.
+ */
 export const keyvalIsLower = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_is_lower", [
         {
@@ -534,6 +793,10 @@ export const keyvalIsLower = (keyval) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Returns true if the given key value is in upper case.
+ * @param keyval - a key value.
+ */
 export const keyvalIsUpper = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_is_upper", [
         {
@@ -542,6 +805,14 @@ export const keyvalIsUpper = (keyval) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Converts a key value into a symbolic name.
+ *
+ * The names are the same as those in the
+ * `gdk/gdkkeysyms.h` header file
+ * but without the leading “GDK_KEY_”.
+ * @param keyval - a key value
+ */
 export const keyvalName = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_name", [
         {
@@ -550,6 +821,10 @@ export const keyvalName = (keyval) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Converts a key value to lower case, if applicable.
+ * @param keyval - a key value.
+ */
 export const keyvalToLower = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_to_lower", [
         {
@@ -558,6 +833,15 @@ export const keyvalToLower = (keyval) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Converts from a GDK key symbol to the corresponding Unicode
+ * character.
+ *
+ * Note that the conversion does not take the current locale
+ * into consideration, which might be expected for particular
+ * keyvals, such as `GDK_KEY_KP_Decimal`.
+ * @param keyval - a GDK key symbol
+ */
 export const keyvalToUnicode = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_to_unicode", [
         {
@@ -566,6 +850,10 @@ export const keyvalToUnicode = (keyval) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Converts a key value to upper case, if applicable.
+ * @param keyval - a key value.
+ */
 export const keyvalToUpper = (keyval) => {
     return call("libgtk-4.so.1", "gdk_keyval_to_upper", [
         {
@@ -574,6 +862,17 @@ export const keyvalToUpper = (keyval) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Returns a paintable that has the given intrinsic size and draws nothing.
+ *
+ * This is often useful for implementing the
+ * [vfunc@Gdk.Paintable.get_current_image] virtual function
+ * when the paintable is in an incomplete state (like a
+ * GtkMediaStream before receiving
+ * the first frame).
+ * @param intrinsicWidth - The intrinsic width to report. Can be 0 for no width.
+ * @param intrinsicHeight - The intrinsic height to report. Can be 0 for no height.
+ */
 export const paintableNewEmpty = (intrinsicWidth, intrinsicHeight) => {
     const ptr = call("libgtk-4.so.1", "gdk_paintable_new_empty", [
         {
@@ -587,6 +886,20 @@ export const paintableNewEmpty = (intrinsicWidth, intrinsicHeight) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, Paintable);
 };
+/**
+ * Transfers image data from a `cairo_surface_t` and converts it
+ * to a `GdkPixbuf`.
+ *
+ * This allows you to efficiently read individual pixels from cairo surfaces.
+ *
+ * This function will create an RGB pixbuf with 8 bits per channel.
+ * The pixbuf will contain an alpha channel if the `surface` contains one.
+ * @param surface - surface to copy from
+ * @param srcX - Source X coordinate within @surface
+ * @param srcY - Source Y coordinate within @surface
+ * @param width - Width in pixels of region to get
+ * @param height - Height in pixels of region to get
+ */
 export const pixbufGetFromSurface = (surface, srcX, srcY, width, height) => {
     const ptr = call("libgtk-4.so.1", "gdk_pixbuf_get_from_surface", [
         {
@@ -619,6 +932,14 @@ export const pixbufGetFromSurface = (surface, srcX, srcY, width, height) => {
         return null;
     return getObject(ptr, GdkPixbuf.Pixbuf);
 };
+/**
+ * Creates a new pixbuf from @texture.
+ *
+ * This should generally not be used in newly written code as later
+ * stages will almost certainly convert the pixbuf back into a texture
+ * to draw it on screen.
+ * @param texture - a `GdkTexture`
+ */
 export const pixbufGetFromTexture = (texture) => {
     const ptr = call("libgtk-4.so.1", "gdk_pixbuf_get_from_texture", [
         {
@@ -630,6 +951,42 @@ export const pixbufGetFromTexture = (texture) => {
         return null;
     return getObject(ptr, GdkPixbuf.Pixbuf);
 };
+/**
+ * Sets a list of backends that GDK should try to use.
+ *
+ * This can be useful if your application does not
+ * work with certain GDK backends.
+ *
+ * By default, GDK tries all included backends.
+ *
+ * For example:
+ *
+ * ```c
+ * gdk_set_allowed_backends ("wayland,macos,*");
+ * ```
+ *
+ * instructs GDK to try the Wayland backend first, followed by the
+ * MacOs backend, and then all others.
+ *
+ * If the `GDK_BACKEND` environment variable is set, it determines
+ * what backends are tried in what order, while still respecting the
+ * set of allowed backends that are specified by this function.
+ *
+ * The possible backend names are:
+ *
+ * - `broadway`
+ * - `macos`
+ * - `wayland`.
+ * - `win32`
+ * - `x11`
+ *
+ * You can also include a `*` in the list to try all remaining backends.
+ *
+ * This call must happen prior to functions that open a display, such
+ * as [func@Gdk.Display.open], `gtk_init()`, or `gtk_init_check()`
+ * in order to take effect.
+ * @param backends - a comma-separated list of backends
+ */
 export const setAllowedBackends = (backends) => {
     call("libgtk-4.so.1", "gdk_set_allowed_backends", [
         {
@@ -638,6 +995,9 @@ export const setAllowedBackends = (backends) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers an error quark for [class@Gdk.Texture] errors.
+ */
 export const textureErrorQuark = () => {
     return call("libgtk-4.so.1", "gdk_texture_error_quark", [], {
         type: "int",
@@ -645,6 +1005,10 @@ export const textureErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Converts from a Unicode character to a key symbol.
+ * @param wc - a Unicode character
+ */
 export const unicodeToKeyval = (wc) => {
     return call("libgtk-4.so.1", "gdk_unicode_to_keyval", [
         {
@@ -653,6 +1017,9 @@ export const unicodeToKeyval = (wc) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Registers an error quark for [class@Gdk.VulkanContext] errors.
+ */
 export const vulkanErrorQuark = () => {
     return call("libgtk-4.so.1", "gdk_vulkan_error_quark", [], {
         type: "int",