@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gdk/functions.d.ts

@@ -12,44 +12,411 @@ import * as GObject from "../gobject/index.js";
 import * as GdkPixbuf from "../gdkpixbuf/index.js";
 import * as Gio from "../gio/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 declare const cairoDrawFromGl: (cr: cairo.Context, surface: Surface, source: number, sourceType: number, bufferScale: number, x: number, y: number, width: number, height: number) => void;
+/**
+ * Adds the given rectangle to the current path of @cr.
+ * @param cr - a cairo context
+ * @param rectangle - a `GdkRectangle`
+ */
 export declare const cairoRectangle: (cr: cairo.Context, rectangle: Rectangle) => void;
+/**
+ * Adds the given region to the current path of @cr.
+ * @param cr - a cairo context
+ * @param region - a `cairo_region_t`
+ */
 export declare const cairoRegion: (cr: cairo.Context, region: cairo.Region) => void;
+/**
+ * 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 declare const cairoRegionCreateFromSurface: (surface: cairo.Surface) => 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 declare const cairoSetSourcePixbuf: (cr: cairo.Context, pixbuf: GdkPixbuf.Pixbuf, pixbufX: number, pixbufY: number) => void;
+/**
+ * Sets the specified `GdkRGBA` as the source color of @cr.
+ * @param cr - a cairo context
+ * @param rgba - a `GdkRGBA`
+ */
 export declare const cairoSetSourceRgba: (cr: cairo.Context, rgba: RGBA) => void;
+/**
+ * Returns the color state object representing the oklab color space.
+ *
+ * This is a perceptually uniform color state.
+ */
 export declare const colorStateGetOklab: () => 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 declare const colorStateGetOklch: () => 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 declare const colorStateGetRec2100Linear: () => 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 declare const colorStateGetRec2100Pq: () => 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 declare const colorStateGetSrgb: () => 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 declare const colorStateGetSrgbLinear: () => 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 declare const contentDeserializeAsync: (stream: Gio.InputStream, mimeType: string, type: number, ioPriority: number, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null) => void;
+/**
+ * Finishes a content deserialization operation.
+ * @param result - the `GAsyncResult`
+ * @param value - return location for the result of the operation
+ */
 export declare const contentDeserializeFinish: (result: Gio.AsyncResult, value: Ref<GObject.Value>) => boolean;
+/**
+ * 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 declare const contentFormatsParse: (string: string) => ContentFormats | null;
+/**
+ * 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 declare const contentRegisterDeserializer: (mimeType: string, type: number, deserialize: (...args: unknown[]) => unknown, notify: () => void, data?: number | null) => void;
+/**
+ * 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 declare const contentRegisterSerializer: (type: number, mimeType: string, serialize: (...args: unknown[]) => unknown, notify: () => void, data?: number | null) => void;
+/**
+ * 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 declare const contentSerializeAsync: (stream: Gio.OutputStream, mimeType: string, value: GObject.Value, ioPriority: number, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null) => void;
+/**
+ * Finishes a content serialization operation.
+ * @param result - the `GAsyncResult`
+ */
 export declare const contentSerializeFinish: (result: Gio.AsyncResult) => boolean;
+/**
+ * Registers an error quark for [class@Gdk.DmabufTexture] errors.
+ */
 export declare const dmabufErrorQuark: () => number;
+/**
+ * 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 declare const dragActionIsUnique: (action: DragAction) => 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 declare const eventsGetAngle: (event1: Event, event2: Event, angle: Ref<number>) => 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 declare const eventsGetCenter: (event1: Event, event2: Event, x: Ref<number>, y: Ref<number>) => 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 declare const eventsGetDistance: (event1: Event, event2: Event, distance: Ref<number>) => boolean;
+/**
+ * Registers an error quark for [class@Gdk.GLContext] errors.
+ */
 export declare const glErrorQuark: () => number;
+/**
+ * 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 declare const internMimeType: (string: string) => string | null;
+/**
+ * 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 declare const keyvalConvertCase: (symbol: number, lower: Ref<number>, upper: Ref<number>) => void;
+/**
+ * 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 declare const keyvalFromName: (keyvalName: string) => number;
+/**
+ * Returns true if the given key value is in lower case.
+ * @param keyval - a key value.
+ */
 export declare const keyvalIsLower: (keyval: number) => boolean;
+/**
+ * Returns true if the given key value is in upper case.
+ * @param keyval - a key value.
+ */
 export declare const keyvalIsUpper: (keyval: number) => 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 declare const keyvalName: (keyval: number) => string | null;
+/**
+ * Converts a key value to lower case, if applicable.
+ * @param keyval - a key value.
+ */
 export declare const keyvalToLower: (keyval: number) => number;
+/**
+ * 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 declare const keyvalToUnicode: (keyval: number) => number;
+/**
+ * Converts a key value to upper case, if applicable.
+ * @param keyval - a key value.
+ */
 export declare const keyvalToUpper: (keyval: number) => number;
+/**
+ * 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 declare const paintableNewEmpty: (intrinsicWidth: number, intrinsicHeight: number) => 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 declare const pixbufGetFromSurface: (surface: cairo.Surface, srcX: number, srcY: number, width: number, height: number) => GdkPixbuf.Pixbuf | null;
+/**
+ * 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 declare const pixbufGetFromTexture: (texture: Texture) => GdkPixbuf.Pixbuf | null;
+/**
+ * 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 declare const setAllowedBackends: (backends: string) => void;
+/**
+ * Registers an error quark for [class@Gdk.Texture] errors.
+ */
 export declare const textureErrorQuark: () => number;
+/**
+ * Converts from a Unicode character to a key symbol.
+ * @param wc - a Unicode character
+ */
 export declare const unicodeToKeyval: (wc: number) => number;
+/**
+ * Registers an error quark for [class@Gdk.VulkanContext] errors.
+ */
 export declare const vulkanErrorQuark: () => number;