/* * Type Definitions for Gjs (https://gjs.guide/) * * These type definitions are automatically generated, do not edit them by hand. * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gjs */ import type Gio from "gi://Gio?version=2.0"; import type GObject from "gi://GObject?version=2.0"; import type GLib from "gi://GLib?version=2.0"; import type GModule from "gi://GModule?version=2.0"; declare module "gi://GdkPixbuf?version=2.0" { /** * This enumeration defines the color spaces that are supported by * the gdk-pixbuf library. * * Currently only RGB is supported. */ enum Colorspace { /** * Indicates a red/green/blue additive color space. */ RGB, } /** * Interpolation modes for scaling functions. * * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best * choice if you aren't sure what to choose, it has a good speed/quality * balance. * * **Note**: Cubic filtering is missing from the list; hyperbolic * interpolation is just as fast and results in higher quality. */ enum InterpType { /** * Nearest neighbor sampling; this is the fastest * and lowest quality mode. Quality is normally unacceptable when scaling * down, but may be OK when scaling up. */ NEAREST, /** * This is an accurate simulation of the PostScript * image operator without any interpolation enabled. Each pixel is * rendered as a tiny parallelogram of solid color, the edges of which * are implemented with antialiasing. It resembles nearest neighbor for * enlargement, and bilinear for reduction. */ TILES, /** * Best quality/speed balance; use this mode by * default. Bilinear interpolation. For enlargement, it is * equivalent to point-sampling the ideal bilinear-interpolated image. * For reduction, it is equivalent to laying down small tiles and * integrating over the coverage area. */ BILINEAR, /** * This is the slowest and highest quality * reconstruction function. It is derived from the hyperbolic filters in * Wolberg's "Digital Image Warping", and is formally defined as the * hyperbolic-filter sampling the ideal hyperbolic-filter interpolated * image (the filter is designed to be idempotent for 1:1 pixel mapping). * **Deprecated**: this interpolation filter is deprecated, as in reality * it has a lower quality than the `GDK_INTERP_BILINEAR` filter * (Since: 2.38) */ HYPER, } /** * Control the alpha channel for drawables. * * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha() * in gdk-pixbuf-xlib to control how the alpha channel of an image should * be handled. * * This function can create a bilevel clipping mask (black and white) and use * it while painting the image. * * In the future, when the X Window System gets an alpha channel extension, * it will be possible to do full alpha compositing onto arbitrary drawables. * For now both cases fall back to a bilevel clipping mask. */ enum PixbufAlphaMode { /** * A bilevel clipping mask (black and white) * will be created and used to draw the image. Pixels below 0.5 opacity * will be considered fully transparent, and all others will be * considered fully opaque. */ BILEVEL, /** * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL. * In the future it will do full alpha compositing. */ FULL, } /** * An error code in the `GDK_PIXBUF_ERROR` domain. * * Many gdk-pixbuf operations can cause errors in this domain, or in * the `G_FILE_ERROR` domain. */ enum PixbufError { /** * An image file was broken somehow. */ CORRUPT_IMAGE, /** * Not enough memory. */ INSUFFICIENT_MEMORY, /** * A bad option was passed to a pixbuf save module. */ BAD_OPTION, /** * Unknown image type. */ UNKNOWN_TYPE, /** * Don't know how to perform the * given operation on the type of image at hand. */ UNSUPPORTED_OPERATION, /** * Generic failure code, something went wrong. */ FAILED, /** * Only part of the animation was loaded. */ INCOMPLETE_ANIMATION, } /** * The possible rotations which can be passed to gdk_pixbuf_rotate_simple(). * * To make them easier to use, their numerical values are the actual degrees. */ enum PixbufRotation { /** * No rotation. */ NONE, /** * Rotate by 90 degrees. */ COUNTERCLOCKWISE, /** * Rotate by 180 degrees. */ UPSIDEDOWN, /** * Rotate by 270 degrees. */ CLOCKWISE, } /** * Flags which allow a module to specify further details about the supported * operations. * @bitfield */ enum PixbufFormatFlags { /** * the module can write out images in the format. */ WRITABLE, /** * the image format is scalable */ SCALABLE, /** * the module is threadsafe. gdk-pixbuf * ignores modules that are not marked as threadsafe. (Since 2.28). */ THREADSAFE, } /** * Major version of gdk-pixbuf library, that is the "0" in * "0.8.2" for example. */ const PIXBUF_MAJOR: number; /** * Micro version of gdk-pixbuf library, that is the "2" in * "0.8.2" for example. */ const PIXBUF_MICRO: number; /** * Minor version of gdk-pixbuf library, that is the "8" in * "0.8.2" for example. */ const PIXBUF_MINOR: number; /** * Contains the full version of GdkPixbuf as a string. * * This is the version being compiled against; contrast with * `gdk_pixbuf_version`. */ const PIXBUF_VERSION: string | null; function pixbuf_error_quark(): GLib.Quark; /** * A function of this type is responsible for freeing the pixel array * of a pixbuf. * * The gdk_pixbuf_new_from_data() function lets you pass in a pre-allocated * pixel array so that a pixbuf can be created from it; in this case you * will need to pass in a function of type `GdkPixbufDestroyNotify` so that * the pixel data can be freed when the pixbuf is finalized. * @callback * @param pixels The pixel array of the pixbuf that is being finalized. */ interface PixbufDestroyNotify { (pixels: Uint8Array): void; } /** * Defines the type of the function used to fill a * #GdkPixbufFormat structure with information about a module. * @callback * @param info a #GdkPixbufFormat. */ interface PixbufModuleFillInfoFunc { (info: PixbufFormat): void; } /** * Defines the type of the function used to set the vtable of a * #GdkPixbufModule when it is loaded. * @callback * @param module a #GdkPixbufModule. */ interface PixbufModuleFillVtableFunc { (module: PixbufModule): void; } /** * Incrementally loads a buffer into the image data. * @callback * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc] * @param buf the data to load * @returns `TRUE` if the incremental load was successful */ interface PixbufModuleIncrementLoadFunc { (context: any | null, buf: Uint8Array): boolean; } /** * Loads a file from a standard C file stream into a new `GdkPixbufAnimation`. * * In case of error, this function should return `NULL` and set the `error` argument. * @callback * @param f the file stream from which the image should be loaded * @returns a newly created `GdkPixbufAnimation` for the contents of the file */ interface PixbufModuleLoadAnimationFunc { (f: any | null): PixbufAnimation; } /** * Loads a file from a standard C file stream into a new `GdkPixbuf`. * * In case of error, this function should return `NULL` and set the `error` argument. * @callback * @param f the file stream from which the image should be loaded * @returns a newly created `GdkPixbuf` for the contents of the file */ interface PixbufModuleLoadFunc { (f: any | null): Pixbuf; } /** * Loads XPM data into a new `GdkPixbuf`. * @callback * @param data the XPM data * @returns a newly created `GdkPixbuf` for the XPM data */ interface PixbufModuleLoadXpmDataFunc { (data: string[]): Pixbuf; } /** * Defines the type of the function that gets called once the initial * setup of `pixbuf` is done. * * #GdkPixbufLoader uses a function of this type to emit the * "area_prepared" * signal. * @callback * @param pixbuf the #GdkPixbuf that is currently being loaded. * @param anim if an animation is being loaded, the #GdkPixbufAnimation, else %NULL. */ interface PixbufModulePreparedFunc { (pixbuf: Pixbuf, anim: PixbufAnimation): void; } /** * Saves a `GdkPixbuf` into a standard C file stream. * * The optional `param_keys` and `param_values` arrays contain the keys and * values (in the same order) for attributes to be saved alongside the image * data. * @callback * @param f the file stream into which the image should be saved * @param pixbuf the image to save * @param param_keys parameter keys to save * @param param_values parameter values to save * @returns `TRUE` on success; in case of failure, `FALSE` is returned and the `error` is set */ interface PixbufModuleSaveFunc { ( f: any | null, pixbuf: Pixbuf, param_keys: string[] | null, param_values: string[] | null ): boolean; } /** * Checks whether the given `option_key` is supported when saving. * @callback * @param option_key the option key to check * @returns `TRUE` if the option is supported */ interface PixbufModuleSaveOptionSupportedFunc { (option_key: string | null): boolean; } /** * Defines the type of the function that gets called once the size * of the loaded image is known. * * The function is expected to set `width` and `height` to the desired * size to which the image should be scaled. If a module has no efficient * way to achieve the desired scaling during the loading of the image, it may * either ignore the size request, or only approximate it - gdk-pixbuf will * then perform the required scaling on the completely loaded image. * * If the function sets `width` or `height` to zero, the module should interpret * this as a hint that it will be closed soon and shouldn't allocate further * resources. This convention is used to implement gdk_pixbuf_get_file_info() * efficiently. * @callback * @param width pointer to a location containing the current image width * @param height pointer to a location containing the current image height */ interface PixbufModuleSizeFunc { (width: number, height: number): void; } /** * Finalizes the image loading state. * * This function is called on success and error states. * @callback * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc] * @returns `TRUE` if the loading operation was successful */ interface PixbufModuleStopLoadFunc { (context: any | null): boolean; } /** * Defines the type of the function that gets called every time a region * of `pixbuf` is updated. * * #GdkPixbufLoader uses a function of this type to emit the * "area_updated" * signal. * @callback * @param pixbuf the #GdkPixbuf that is currently being loaded. * @param x the X origin of the updated area. * @param y the Y origin of the updated area. * @param width the width of the updated area. * @param height the height of the updated area. */ interface PixbufModuleUpdatedFunc { (pixbuf: Pixbuf, x: number, y: number, width: number, height: number): void; } /** * Save functions used by [method`GdkPixbuf`.Pixbuf.save_to_callback]. * * This function is called once for each block of bytes that is "written" * by `gdk_pixbuf_save_to_callback()`. * * If successful it should return `TRUE`; if an error occurs it should set * `error` and return `FALSE`, in which case `gdk_pixbuf_save_to_callback()` * will fail with the same error. * @callback * @param buf bytes to be written. * @returns `TRUE` if successful, `FALSE` otherwise */ interface PixbufSaveFunc { (buf: Uint8Array): boolean; } module Pixbuf { // Constructor properties interface interface ConstructorProperties extends Gio.Icon.ConstructorProperties, Gio.LoadableIcon.ConstructorProperties, GObject.Object.ConstructorProperties { // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf /** * The number of bits per sample. * * Currently only 8 bit per sample are supported. */ bits_per_sample?: number | null; /** * The color space of the pixbuf. * * Currently, only `GDK_COLORSPACE_RGB` is supported. */ colorspace?: Colorspace | null; /** * Whether the pixbuf has an alpha channel. */ has_alpha?: boolean | null; /** * The number of rows of the pixbuf. */ height?: number | null; /** * The number of samples per pixel. * * Currently, only 3 or 4 samples per pixel are supported. */ n_channels?: number | null; pixel_bytes?: GLib.Bytes | null; /** * A pointer to the pixel data of the pixbuf. */ pixels?: any | null; /** * The number of bytes between the start of a row and * the start of the next row. * * This number must (obviously) be at least as large as the * width of the pixbuf. */ rowstride?: number | null; /** * The number of columns of the pixbuf. */ width?: number | null; } } interface Pixbuf extends Gio.Icon, Gio.LoadableIcon { // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf /** * The number of bits per sample. * * Currently only 8 bit per sample are supported. */ readonly bits_per_sample: number; /** * The color space of the pixbuf. * * Currently, only `GDK_COLORSPACE_RGB` is supported. */ readonly colorspace: Colorspace; /** * Whether the pixbuf has an alpha channel. */ readonly has_alpha: boolean; /** * The number of rows of the pixbuf. */ readonly height: number; /** * The number of samples per pixel. * * Currently, only 3 or 4 samples per pixel are supported. */ readonly n_channels: number; readonly pixel_bytes: GLib.Bytes; /** * A pointer to the pixel data of the pixbuf. */ readonly pixels: any; /** * The number of bytes between the start of a row and * the start of the next row. * * This number must (obviously) be at least as large as the * width of the pixbuf. */ readonly rowstride: number; /** * The number of columns of the pixbuf. */ readonly width: number; // Owm methods of GdkPixbuf-2.0.GdkPixbuf.Pixbuf /** * Takes an existing pixbuf and adds an alpha channel to it. * * If the existing pixbuf already had an alpha channel, the channel * values are copied from the original; otherwise, the alpha channel * is initialized to 255 (full opacity). * * If `substitute_color` is `TRUE`, then the color specified by the * (`r`, `g`, `b`) arguments will be assigned zero opacity. That is, * if you pass `(255, 255, 255)` for the substitute color, all white * pixels will become fully transparent. * * If `substitute_color` is `FALSE`, then the (`r`, `g`, `b`) arguments * will be ignored. * @param substitute_color Whether to set a color to zero opacity. * @param r Red value to substitute. * @param g Green value to substitute. * @param b Blue value to substitute. * @returns A newly-created pixbuf */ add_alpha( substitute_color: boolean, r: number, g: number, b: number ): Pixbuf; /** * Takes an existing pixbuf and checks for the presence of an * associated "orientation" option. * * The orientation option may be provided by the JPEG loader (which * reads the exif orientation tag) or the TIFF loader (which reads * the TIFF orientation tag, and compensates it for the partial * transforms performed by libtiff). * * If an orientation option/tag is present, the appropriate transform * will be performed so that the pixbuf is oriented correctly. * @returns A newly-created pixbuf */ apply_embedded_orientation(): Pixbuf | null; /** * Creates a transformation of the source image `src` by scaling by * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y`. * * This gives an image in the coordinates of the destination pixbuf. * The rectangle (`dest_x,` `dest_y,` `dest_width,` `dest_height)` * is then alpha blended onto the corresponding rectangle of the * original destination image. * * When the destination rectangle contains parts not in the source * image, the data at the edges of the source image is replicated * to infinity. * * ![](composite.png) * @param dest the #GdkPixbuf into which to render the results * @param dest_x the left coordinate for region to render * @param dest_y the top coordinate for region to render * @param dest_width the width of the region to render * @param dest_height the height of the region to render * @param offset_x the offset in the X direction (currently rounded to an integer) * @param offset_y the offset in the Y direction (currently rounded to an integer) * @param scale_x the scale factor in the X direction * @param scale_y the scale factor in the Y direction * @param interp_type the interpolation type for the transformation. * @param overall_alpha overall alpha for source image (0..255) */ composite( dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: InterpType, overall_alpha: number ): void; /** * Creates a transformation of the source image `src` by scaling by * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,` * then alpha blends the rectangle (`dest_x` ,`dest_y,` `dest_width,` * `dest_height)` of the resulting image with a checkboard of the * colors `color1` and `color2` and renders it onto the destination * image. * * If the source image has no alpha channel, and `overall_alpha` is 255, a fast * path is used which omits the alpha blending and just performs the scaling. * * See gdk_pixbuf_composite_color_simple() for a simpler variant of this * function suitable for many tasks. * @param dest the #GdkPixbuf into which to render the results * @param dest_x the left coordinate for region to render * @param dest_y the top coordinate for region to render * @param dest_width the width of the region to render * @param dest_height the height of the region to render * @param offset_x the offset in the X direction (currently rounded to an integer) * @param offset_y the offset in the Y direction (currently rounded to an integer) * @param scale_x the scale factor in the X direction * @param scale_y the scale factor in the Y direction * @param interp_type the interpolation type for the transformation. * @param overall_alpha overall alpha for source image (0..255) * @param check_x the X offset for the checkboard (origin of checkboard is at -`check_x,` -`check_y)` * @param check_y the Y offset for the checkboard * @param check_size the size of checks in the checkboard (must be a power of two) * @param color1 the color of check at upper left * @param color2 the color of the other check */ composite_color( dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: InterpType, overall_alpha: number, check_x: number, check_y: number, check_size: number, color1: number, color2: number ): void; /** * Creates a new pixbuf by scaling `src` to `dest_width` x `dest_height` * and alpha blending the result with a checkboard of colors `color1` * and `color2`. * @param dest_width the width of destination image * @param dest_height the height of destination image * @param interp_type the interpolation type for the transformation. * @param overall_alpha overall alpha for source image (0..255) * @param check_size the size of checks in the checkboard (must be a power of two) * @param color1 the color of check at upper left * @param color2 the color of the other check * @returns the new pixbuf */ composite_color_simple( dest_width: number, dest_height: number, interp_type: InterpType, overall_alpha: number, check_size: number, color1: number, color2: number ): Pixbuf | null; /** * Creates a new `GdkPixbuf` with a copy of the information in the specified * `pixbuf`. * * Note that this does not copy the options set on the original `GdkPixbuf`, * use gdk_pixbuf_copy_options() for this. * @returns A newly-created pixbuf */ copy(): Pixbuf | null; /** * Copies a rectangular area from `src_pixbuf` to `dest_pixbuf`. * * Conversion of pixbuf formats is done automatically. * * If the source rectangle overlaps the destination rectangle on the * same pixbuf, it will be overwritten during the copy operation. * Therefore, you can not use this function to scroll a pixbuf. * @param src_x Source X coordinate within `src_pixbuf`. * @param src_y Source Y coordinate within `src_pixbuf`. * @param width Width of the area to copy. * @param height Height of the area to copy. * @param dest_pixbuf Destination pixbuf. * @param dest_x X coordinate within `dest_pixbuf`. * @param dest_y Y coordinate within `dest_pixbuf`. */ copy_area( src_x: number, src_y: number, width: number, height: number, dest_pixbuf: Pixbuf, dest_x: number, dest_y: number ): void; /** * Copies the key/value pair options attached to a `GdkPixbuf` to another * `GdkPixbuf`. * * This is useful to keep original metadata after having manipulated * a file. However be careful to remove metadata which you've already * applied, such as the "orientation" option after rotating the image. * @param dest_pixbuf the destination pixbuf * @returns `TRUE` on success. */ copy_options(dest_pixbuf: Pixbuf): boolean; /** * Clears a pixbuf to the given RGBA value, converting the RGBA value into * the pixbuf's pixel format. * * The alpha component will be ignored if the pixbuf doesn't have an alpha * channel. * @param pixel RGBA pixel to used to clear (`0xffffffff` is opaque white, `0x00000000` transparent black) */ fill(pixel: number): void; /** * Flips a pixbuf horizontally or vertically and returns the * result in a new pixbuf. * @param horizontal `TRUE` to flip horizontally, `FALSE` to flip vertically * @returns the new pixbuf */ flip(horizontal: boolean): Pixbuf | null; /** * Queries the number of bits per color sample in a pixbuf. * @returns Number of bits per color sample. */ get_bits_per_sample(): number; /** * Returns the length of the pixel data, in bytes. * @returns The length of the pixel data. */ get_byte_length(): number; /** * Queries the color space of a pixbuf. * @returns Color space. */ get_colorspace(): Colorspace; /** * Queries whether a pixbuf has an alpha channel (opacity information). * @returns `TRUE` if it has an alpha channel, `FALSE` otherwise. */ get_has_alpha(): boolean; /** * Queries the height of a pixbuf. * @returns Height in pixels. */ get_height(): number; /** * Queries the number of channels of a pixbuf. * @returns Number of channels. */ get_n_channels(): number; /** * Looks up `key` in the list of options that may have been attached to the * `pixbuf` when it was loaded, or that may have been attached by another * function using gdk_pixbuf_set_option(). * * For instance, the ANI loader provides "Title" and "Artist" options. * The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot * options for cursor definitions. The PNG loader provides the tEXt ancillary * chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders * return an "orientation" option string that corresponds to the embedded * TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets * the "multipage" option string to "yes" when a multi-page TIFF is loaded. * Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file * contains image density information in dots per inch. * Since 2.36.6, the JPEG loader sets the "comment" option with the comment * EXIF tag. * @param key a nul-terminated string. * @returns the value associated with `key` */ get_option(key: string | null): string | null; /** * Returns a `GHashTable` with a list of all the options that may have been * attached to the `pixbuf` when it was loaded, or that may have been * attached by another function using [method`GdkPixbuf`.Pixbuf.set_option]. * @returns a #GHashTable of key/values pairs */ get_options(): GLib.HashTable; /** * Queries a pointer to the pixel data of a pixbuf. * * This function will cause an implicit copy of the pixbuf data if the * pixbuf was created from read-only data. * * Please see the section on [image data](class.Pixbuf.html#image-data) for information * about how the pixel data is stored in memory. * @returns A pointer to the pixbuf's pixel data. */ get_pixels(): Uint8Array; /** * Queries the rowstride of a pixbuf, which is the number of bytes between * the start of a row and the start of the next row. * @returns Distance between row starts. */ get_rowstride(): number; /** * Queries the width of a pixbuf. * @returns Width in pixels. */ get_width(): number; /** * Creates a new pixbuf which represents a sub-region of `src_pixbuf`. * * The new pixbuf shares its pixels with the original pixbuf, so * writing to one affects both. The new pixbuf holds a reference to * `src_pixbuf`, so `src_pixbuf` will not be finalized until the new * pixbuf is finalized. * * Note that if `src_pixbuf` is read-only, this function will force it * to be mutable. * @param src_x X coord in `src_pixbuf` * @param src_y Y coord in `src_pixbuf` * @param width width of region in `src_pixbuf` * @param height height of region in `src_pixbuf` * @returns a new pixbuf */ new_subpixbuf( src_x: number, src_y: number, width: number, height: number ): Pixbuf; /** * Provides a #GBytes buffer containing the raw pixel data; the data * must not be modified. * * This function allows skipping the implicit copy that must be made * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf. * @returns A new reference to a read-only copy of the pixel data. Note that for mutable pixbufs, this function will incur a one-time copy of the pixel data for conversion into the returned #GBytes. */ read_pixel_bytes(): GLib.Bytes; /** * Provides a read-only pointer to the raw pixel data. * * This function allows skipping the implicit copy that must be made * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf. * @returns a read-only pointer to the raw pixel data */ read_pixels(): number; /** * Removes the key/value pair option attached to a `GdkPixbuf`. * @param key a nul-terminated string representing the key to remove. * @returns `TRUE` if an option was removed, `FALSE` if not. */ remove_option(key: string | null): boolean; /** * Rotates a pixbuf by a multiple of 90 degrees, and returns the * result in a new pixbuf. * * If `angle` is 0, this function will return a copy of `src`. * @param angle the angle to rotate by * @returns the new pixbuf */ rotate_simple(angle: PixbufRotation): Pixbuf | null; /** * Modifies saturation and optionally pixelates `src`, placing the result in * `dest`. * * The `src` and `dest` pixbufs must have the same image format, size, and * rowstride. * * The `src` and `dest` arguments may be the same pixbuf with no ill effects. * * If `saturation` is 1.0 then saturation is not changed. If it's less than 1.0, * saturation is reduced (the image turns toward grayscale); if greater than * 1.0, saturation is increased (the image gets more vivid colors). * * If `pixelate` is `TRUE`, then pixels are faded in a checkerboard pattern to * create a pixelated image. * @param dest place to write modified version of `src` * @param saturation saturation factor * @param pixelate whether to pixelate */ saturate_and_pixelate( dest: Pixbuf, saturation: number, pixelate: boolean ): void; /** * Vector version of `gdk_pixbuf_save_to_buffer()`. * * Saves pixbuf to a new buffer in format `type,` which is currently "jpeg", * "tiff", "png", "ico" or "bmp". * * See [method`GdkPixbuf`.Pixbuf.save_to_buffer] for more details. * @param type name of file format. * @param option_keys name of options to set * @param option_values values for named options * @returns whether an error was set */ save_to_bufferv( type: string | null, option_keys: string[] | null, option_values: string[] | null ): [/* returnType */ boolean, /* buffer */ Uint8Array]; /** * Vector version of `gdk_pixbuf_save_to_callback()`. * * Saves pixbuf to a callback in format `type,` which is currently "jpeg", * "png", "tiff", "ico" or "bmp". * * If `error` is set, `FALSE` will be returned. * * See [method`GdkPixbuf`.Pixbuf.save_to_callback] for more details. * @param save_func a function that is called to save each block of data that the save routine generates. * @param type name of file format. * @param option_keys name of options to set * @param option_values values for named options * @returns whether an error was set */ save_to_callbackv( save_func: PixbufSaveFunc, type: string | null, option_keys: string[] | null, option_values: string[] | null ): boolean; /** * Saves `pixbuf` to an output stream. * * Supported file formats are currently "jpeg", "tiff", "png", "ico" or * "bmp". * * See [method`GdkPixbuf`.Pixbuf.save_to_stream] for more details. * @param stream a `GOutputStream` to save the pixbuf to * @param type name of file format * @param option_keys name of options to set * @param option_values values for named options * @param cancellable optional `GCancellable` object, `NULL` to ignore * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set. */ save_to_streamv( stream: Gio.OutputStream, type: string | null, option_keys: string[] | null, option_values: string[] | null, cancellable: Gio.Cancellable | null ): boolean; /** * Saves `pixbuf` to an output stream asynchronously. * * For more details see gdk_pixbuf_save_to_streamv(), which is the synchronous * version of this function. * * When the operation is finished, `callback` will be called in the main thread. * * You can then call gdk_pixbuf_save_to_stream_finish() to get the result of * the operation. * @param stream a `GOutputStream` to which to save the pixbuf * @param type name of file format * @param option_keys name of options to set * @param option_values values for named options * @param cancellable optional `GCancellable` object, `NULL` to ignore * @param callback a `GAsyncReadyCallback` to call when the pixbuf is saved */ save_to_streamv_async( stream: Gio.OutputStream, type: string | null, option_keys: string[] | null, option_values: string[] | null, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null ): void; /** * Vector version of `gdk_pixbuf_save()`. * * Saves pixbuf to a file in `type`, which is currently "jpeg", "png", "tiff", "ico" or "bmp". * * If `error` is set, `FALSE` will be returned. * * See [method`GdkPixbuf`.Pixbuf.save] for more details. * @param filename name of file to save. * @param type name of file format. * @param option_keys name of options to set * @param option_values values for named options * @returns whether an error was set */ savev( filename: string, type: string | null, option_keys: string[] | null, option_values: string[] | null ): boolean; /** * Creates a transformation of the source image `src` by scaling by * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,` * then renders the rectangle (`dest_x,` `dest_y,` `dest_width,` * `dest_height)` of the resulting image onto the destination image * replacing the previous contents. * * Try to use gdk_pixbuf_scale_simple() first; this function is * the industrial-strength power tool you can fall back to, if * gdk_pixbuf_scale_simple() isn't powerful enough. * * If the source rectangle overlaps the destination rectangle on the * same pixbuf, it will be overwritten during the scaling which * results in rendering artifacts. * @param dest the #GdkPixbuf into which to render the results * @param dest_x the left coordinate for region to render * @param dest_y the top coordinate for region to render * @param dest_width the width of the region to render * @param dest_height the height of the region to render * @param offset_x the offset in the X direction (currently rounded to an integer) * @param offset_y the offset in the Y direction (currently rounded to an integer) * @param scale_x the scale factor in the X direction * @param scale_y the scale factor in the Y direction * @param interp_type the interpolation type for the transformation. */ scale( dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: InterpType ): void; /** * Create a new pixbuf containing a copy of `src` scaled to * `dest_width` x `dest_height`. * * This function leaves `src` unaffected. * * The `interp_type` should be `GDK_INTERP_NEAREST` if you want maximum * speed (but when scaling down `GDK_INTERP_NEAREST` is usually unusably * ugly). The default `interp_type` should be `GDK_INTERP_BILINEAR` which * offers reasonable quality and speed. * * You can scale a sub-portion of `src` by creating a sub-pixbuf * pointing into `src`; see [method`GdkPixbuf`.Pixbuf.new_subpixbuf]. * * If `dest_width` and `dest_height` are equal to the width and height of * `src`, this function will return an unscaled copy of `src`. * * For more complicated scaling/alpha blending see [method`GdkPixbuf`.Pixbuf.scale] * and [method`GdkPixbuf`.Pixbuf.composite]. * @param dest_width the width of destination image * @param dest_height the height of destination image * @param interp_type the interpolation type for the transformation. * @returns the new pixbuf */ scale_simple( dest_width: number, dest_height: number, interp_type: InterpType ): Pixbuf | null; /** * Attaches a key/value pair as an option to a `GdkPixbuf`. * * If `key` already exists in the list of options attached to the `pixbuf`, * the new value is ignored and `FALSE` is returned. * @param key a nul-terminated string. * @param value a nul-terminated string. * @returns `TRUE` on success */ set_option(key: string | null, value: string | null): boolean; // Class property signals of GdkPixbuf-2.0.GdkPixbuf.Pixbuf connect( sigName: "notify::bits-per-sample", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::bits-per-sample", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::bits-per-sample", ...args: any[]): void; connect( sigName: "notify::colorspace", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::colorspace", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::colorspace", ...args: any[]): void; connect( sigName: "notify::has-alpha", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::has-alpha", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::has-alpha", ...args: any[]): void; connect( sigName: "notify::height", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::height", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::height", ...args: any[]): void; connect( sigName: "notify::n-channels", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::n-channels", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::n-channels", ...args: any[]): void; connect( sigName: "notify::pixel-bytes", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::pixel-bytes", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::pixel-bytes", ...args: any[]): void; connect( sigName: "notify::pixels", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::pixels", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::pixels", ...args: any[]): void; connect( sigName: "notify::rowstride", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::rowstride", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::rowstride", ...args: any[]): void; connect( sigName: "notify::width", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::width", callback: ($obj: Pixbuf, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::width", ...args: any[]): void; connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } /** * 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 [class`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. * * As a special case, you can use the [`ctor`GdkPixbuf`.Pixbuf.new_from_xpm_data`] * function to create a pixbuf from inline XPM image data. * * You can also copy an existing pixbuf with the [method`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 [class`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 * [method`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 [class`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. * @class */ class Pixbuf extends GObject.Object { // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.Pixbuf constructor(config?: Pixbuf.ConstructorProperties); /** * Creates a new `GdkPixbuf` structure and allocates a buffer for it. * * If the allocation of the buffer failed, this function will return `NULL`. * * The buffer has an optimal rowstride. Note that the buffer is not cleared; * you will have to fill it completely yourself. * @constructor * @param colorspace Color space for image * @param has_alpha Whether the image should have transparency information * @param bits_per_sample Number of bits per color sample * @param width Width of image in pixels, must be > 0 * @param height Height of image in pixels, must be > 0 * @returns A newly-created pixel buffer */ constructor( colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number ); /** * Creates a new `GdkPixbuf` structure and allocates a buffer for it. * * If the allocation of the buffer failed, this function will return `NULL`. * * The buffer has an optimal rowstride. Note that the buffer is not cleared; * you will have to fill it completely yourself. * @constructor * @param colorspace Color space for image * @param has_alpha Whether the image should have transparency information * @param bits_per_sample Number of bits per color sample * @param width Width of image in pixels, must be > 0 * @param height Height of image in pixels, must be > 0 * @returns A newly-created pixel buffer */ static new( colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number ): Pixbuf; /** * Creates a new #GdkPixbuf out of in-memory readonly image data. * * Currently only RGB images with 8 bits per sample are supported. * * This is the `GBytes` variant of gdk_pixbuf_new_from_data(), useful * for language bindings. * @constructor * @param data Image data in 8-bit/sample packed format inside a #GBytes * @param colorspace Colorspace for the image data * @param has_alpha Whether the data has an opacity channel * @param bits_per_sample Number of bits per sample * @param width Width of the image in pixels, must be > 0 * @param height Height of the image in pixels, must be > 0 * @param rowstride Distance in bytes between row starts * @returns A newly-created pixbuf */ static new_from_bytes( data: GLib.Bytes, colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number, rowstride: number ): Pixbuf; /** * Creates a new #GdkPixbuf out of in-memory image data. * * Currently only RGB images with 8 bits per sample are supported. * * Since you are providing a pre-allocated pixel buffer, you must also * specify a way to free that data. This is done with a function of * type `GdkPixbufDestroyNotify`. When a pixbuf created with is * finalized, your destroy notification function will be called, and * it is its responsibility to free the pixel array. * * See also: [ctor`GdkPixbuf`.Pixbuf.new_from_bytes] * @constructor * @param data Image data in 8-bit/sample packed format * @param colorspace Colorspace for the image data * @param has_alpha Whether the data has an opacity channel * @param bits_per_sample Number of bits per sample * @param width Width of the image in pixels, must be > 0 * @param height Height of the image in pixels, must be > 0 * @param rowstride Distance in bytes between row starts * @param destroy_fn Function used to free the data when the pixbuf's reference count drops to zero, or %NULL if the data should not be freed * @returns A newly-created pixbuf */ static new_from_data( data: Uint8Array, colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number, rowstride: number, destroy_fn: PixbufDestroyNotify | null ): Pixbuf; /** * Creates a new pixbuf by loading an image from a file. * * The file format is detected automatically. * * If `NULL` is returned, then `error` will be set. Possible errors are: * * - the file could not be opened * - there is no loader for the file's format * - there is not enough memory to allocate the image buffer * - the image buffer contains invalid data * * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`. * @constructor * @param filename Name of file to load, in the GLib file name encoding * @returns A newly-created pixbuf */ static new_from_file(filename: string): Pixbuf; /** * Creates a new pixbuf by loading an image from a file. * * The file format is detected automatically. * * If `NULL` is returned, then `error` will be set. Possible errors are: * * - the file could not be opened * - there is no loader for the file's format * - there is not enough memory to allocate the image buffer * - the image buffer contains invalid data * * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`. * * The image will be scaled to fit in the requested size, optionally preserving * the image's aspect ratio. * * When preserving the aspect ratio, a `width` of -1 will cause the image * to be scaled to the exact given height, and a `height` of -1 will cause * the image to be scaled to the exact given width. When not preserving * aspect ratio, a `width` or `height` of -1 means to not scale the image * at all in that dimension. Negative values for `width` and `height` are * allowed since 2.8. * @constructor * @param filename Name of file to load, in the GLib file name encoding * @param width The width the image should have or -1 to not constrain the width * @param height The height the image should have or -1 to not constrain the height * @param preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio * @returns A newly-created pixbuf */ static new_from_file_at_scale( filename: string, width: number, height: number, preserve_aspect_ratio: boolean ): Pixbuf; /** * Creates a new pixbuf by loading an image from a file. * * The file format is detected automatically. * * If `NULL` is returned, then `error` will be set. Possible errors are: * * - the file could not be opened * - there is no loader for the file's format * - there is not enough memory to allocate the image buffer * - the image buffer contains invalid data * * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`. * * The image will be scaled to fit in the requested size, preserving * the image's aspect ratio. Note that the returned pixbuf may be smaller * than `width` x `height`, if the aspect ratio requires it. To load * and image at the requested size, regardless of aspect ratio, use * [ctor`GdkPixbuf`.Pixbuf.new_from_file_at_scale]. * @constructor * @param filename Name of file to load, in the GLib file name encoding * @param width The width the image should have or -1 to not constrain the width * @param height The height the image should have or -1 to not constrain the height * @returns A newly-created pixbuf */ static new_from_file_at_size( filename: string, width: number, height: number ): Pixbuf; /** * Creates a `GdkPixbuf` from a flat representation that is suitable for * storing as inline data in a program. * * This is useful if you want to ship a program with images, but don't want * to depend on any external files. * * GdkPixbuf ships with a program called `gdk-pixbuf-csource`, which allows * for conversion of `GdkPixbuf`s into such a inline representation. * * In almost all cases, you should pass the `--raw` option to * `gdk-pixbuf-csource`. A sample invocation would be: * * ``` * gdk-pixbuf-csource --raw --name=myimage_inline myimage.png * ``` * * For the typical case where the inline pixbuf is read-only static data, * you don't need to copy the pixel data unless you intend to write to * it, so you can pass `FALSE` for `copy_pixels`. If you pass `--rle` to * `gdk-pixbuf-csource`, a copy will be made even if `copy_pixels` is `FALSE`, * so using this option is generally a bad idea. * * If you create a pixbuf from const inline data compiled into your * program, it's probably safe to ignore errors and disable length checks, * since things will always succeed: * * ```c * pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL); * ``` * * For non-const inline data, you could get out of memory. For untrusted * inline data located at runtime, you could have corrupt inline data in * addition. * @constructor * @param data Byte data containing a serialized `GdkPixdata` structure * @param copy_pixels Whether to copy the pixel data, or use direct pointers `data` for the resulting pixbuf * @returns A newly-created pixbuf */ static new_from_inline(data: Uint8Array, copy_pixels: boolean): Pixbuf; /** * Creates a new pixbuf by loading an image from an resource. * * The file format is detected automatically. If `NULL` is returned, then * `error` will be set. * @constructor * @param resource_path the path of the resource file * @returns A newly-created pixbuf */ static new_from_resource(resource_path: string | null): Pixbuf; /** * Creates a new pixbuf by loading an image from an resource. * * The file format is detected automatically. If `NULL` is returned, then * `error` will be set. * * The image will be scaled to fit in the requested size, optionally * preserving the image's aspect ratio. When preserving the aspect ratio, * a `width` of -1 will cause the image to be scaled to the exact given * height, and a `height` of -1 will cause the image to be scaled to the * exact given width. When not preserving aspect ratio, a `width` or * `height` of -1 means to not scale the image at all in that dimension. * * The stream is not closed. * @constructor * @param resource_path the path of the resource file * @param width The width the image should have or -1 to not constrain the width * @param height The height the image should have or -1 to not constrain the height * @param preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio * @returns A newly-created pixbuf */ static new_from_resource_at_scale( resource_path: string | null, width: number, height: number, preserve_aspect_ratio: boolean ): Pixbuf; /** * Creates a new pixbuf by loading an image from an input stream. * * The file format is detected automatically. * * If `NULL` is returned, then `error` will be set. * * The `cancellable` can be used to abort the operation from another thread. * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and * `G_IO_ERROR` domains. * * The stream is not closed. * @constructor * @param stream a `GInputStream` to load the pixbuf from * @param cancellable optional `GCancellable` object, `NULL` to ignore * @returns A newly-created pixbuf */ static new_from_stream( stream: Gio.InputStream, cancellable: Gio.Cancellable | null ): Pixbuf; /** * Creates a new pixbuf by loading an image from an input stream. * * The file format is detected automatically. If `NULL` is returned, then * `error` will be set. The `cancellable` can be used to abort the operation * from another thread. If the operation was cancelled, the error * `G_IO_ERROR_CANCELLED` will be returned. Other possible errors are in * the `GDK_PIXBUF_ERROR` and `G_IO_ERROR` domains. * * The image will be scaled to fit in the requested size, optionally * preserving the image's aspect ratio. * * When preserving the aspect ratio, a `width` of -1 will cause the image to be * scaled to the exact given height, and a `height` of -1 will cause the image * to be scaled to the exact given width. If both `width` and `height` are * given, this function will behave as if the smaller of the two values * is passed as -1. * * When not preserving aspect ratio, a `width` or `height` of -1 means to not * scale the image at all in that dimension. * * The stream is not closed. * @constructor * @param stream a `GInputStream` to load the pixbuf from * @param width The width the image should have or -1 to not constrain the width * @param height The height the image should have or -1 to not constrain the height * @param preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio * @param cancellable optional `GCancellable` object, `NULL` to ignore * @returns A newly-created pixbuf */ static new_from_stream_at_scale( stream: Gio.InputStream, width: number, height: number, preserve_aspect_ratio: boolean, cancellable: Gio.Cancellable | null ): Pixbuf; /** * Finishes an asynchronous pixbuf creation operation started with * gdk_pixbuf_new_from_stream_async(). * @constructor * @param async_result a `GAsyncResult` * @returns the newly created pixbuf */ static new_from_stream_finish(async_result: Gio.AsyncResult): Pixbuf; /** * Creates a new pixbuf by parsing XPM data in memory. * * This data is commonly the result of including an XPM file into a * program's C source. * @constructor * @param data Pointer to inline XPM data. * @returns A newly-created pixbuf */ static new_from_xpm_data(data: string[]): Pixbuf; _init(config?: Pixbuf.ConstructorProperties): void; /** * Creates a new pixbuf by asynchronously loading an image from an input stream. * * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous * version of this function. * * When the operation is finished, `callback` will be called in the main thread. * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of * the operation. * @param stream a `GInputStream` from which to load the pixbuf * @param cancellable optional `GCancellable` object, `NULL` to ignore * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded */ static new_from_stream_async( stream: Gio.InputStream, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null ): void; /** * Creates a new pixbuf by asynchronously loading an image from an input stream. * * For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous * version of this function. * * When the operation is finished, `callback` will be called in the main thread. * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation. * @param stream a `GInputStream` from which to load the pixbuf * @param width the width the image should have or -1 to not constrain the width * @param height the height the image should have or -1 to not constrain the height * @param preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio * @param cancellable optional `GCancellable` object, `NULL` to ignore * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded */ static new_from_stream_at_scale_async( stream: Gio.InputStream, width: number, height: number, preserve_aspect_ratio: boolean, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null ): void; /** * Calculates the rowstride that an image created with those values would * have. * * This function is useful for front-ends and backends that want to check * image values without needing to create a `GdkPixbuf`. * @param colorspace Color space for image * @param has_alpha Whether the image should have transparency information * @param bits_per_sample Number of bits per color sample * @param width Width of image in pixels, must be > 0 * @param height Height of image in pixels, must be > 0 * @returns the rowstride for the given values, or -1 in case of error. */ static calculate_rowstride( colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number ): number; /** * Parses an image file far enough to determine its format and size. * @param filename The name of the file to identify. * @returns A `GdkPixbufFormat` describing the image format of the file */ static get_file_info( filename: string ): [ /* returnType */ PixbufFormat | null, /* width */ number, /* height */ number ]; /** * Asynchronously parses an image file far enough to determine its * format and size. * * For more details see gdk_pixbuf_get_file_info(), which is the synchronous * version of this function. * * When the operation is finished, `callback` will be called in the * main thread. You can then call gdk_pixbuf_get_file_info_finish() to * get the result of the operation. * @param filename The name of the file to identify * @param cancellable optional `GCancellable` object, `NULL` to ignore * @param callback a `GAsyncReadyCallback` to call when the file info is available */ static get_file_info_async( filename: string, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null ): void; /** * Finishes an asynchronous pixbuf parsing operation started with * gdk_pixbuf_get_file_info_async(). * @param async_result a `GAsyncResult` * @returns A `GdkPixbufFormat` describing the image format of the file */ static get_file_info_finish( async_result: Gio.AsyncResult ): [ /* returnType */ PixbufFormat | null, /* width */ number, /* height */ number ]; /** * Obtains the available information about the image formats supported * by GdkPixbuf. * @returns A list of support image formats. */ static get_formats(): PixbufFormat[]; /** * Initalizes the gdk-pixbuf loader modules referenced by the `loaders.cache` * file present inside that directory. * * This is to be used by applications that want to ship certain loaders * in a different location from the system ones. * * This is needed when the OS or runtime ships a minimal number of loaders * so as to reduce the potential attack surface of carefully crafted image * files, especially for uncommon file types. Applications that require * broader image file types coverage, such as image viewers, would be * expected to ship the gdk-pixbuf modules in a separate location, bundled * with the application in a separate directory from the OS or runtime- * provided modules. * @param path Path to directory where the `loaders.cache` is installed */ static init_modules(path: string | null): boolean; /** * Finishes an asynchronous pixbuf save operation started with * gdk_pixbuf_save_to_stream_async(). * @param async_result a `GAsyncResult` * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set. */ static save_to_stream_finish(async_result: Gio.AsyncResult): boolean; } module PixbufAnimation { // Constructor properties interface type ConstructorProperties = GObject.Object.ConstructorProperties; } interface PixbufAnimation { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation parent_instance: GObject.Object; // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation /** * Queries the height of the bounding box of a pixbuf animation. * @returns Height of the bounding box of the animation. */ get_height(): number; /** * Get an iterator for displaying an animation. * * The iterator provides the frames that should be displayed at a * given time. * * `start_time` would normally come from g_get_current_time(), and marks * the beginning of animation playback. After creating an iterator, you * should immediately display the pixbuf returned by * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install * a timeout (with g_timeout_add()) or by some other mechanism ensure * that you'll update the image after * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time * the image is updated, you should reinstall the timeout with the new, * possibly-changed delay time. * * As a shortcut, if `start_time` is `NULL`, the result of * g_get_current_time() will be used automatically. * * To update the image (i.e. possibly change the result of * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation), * call gdk_pixbuf_animation_iter_advance(). * * If you're using #GdkPixbufLoader, in addition to updating the image * after the delay time, you should also update it whenever you * receive the area_updated signal and * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns * `TRUE`. In this case, the frame currently being fed into the loader * has received new data, so needs to be refreshed. The delay time for * a frame may also be modified after an area_updated signal, for * example if the delay time for a frame is encoded in the data after * the frame itself. So your timeout should be reinstalled after any * area_updated signal. * * A delay time of -1 is possible, indicating "infinite". * @param start_time time when the animation starts playing * @returns an iterator to move over the animation */ get_iter(start_time: GLib.TimeVal | null): PixbufAnimationIter; /** * Retrieves a static image for the animation. * * If an animation is really just a plain image (has only one frame), * this function returns that image. * * If the animation is an animation, this function returns a reasonable * image to use as a static unanimated image, which might be the first * frame, or something more sophisticated depending on the file format. * * If an animation hasn't loaded any frames yet, this function will * return `NULL`. * @returns unanimated image representing the animation */ get_static_image(): Pixbuf; /** * Queries the width of the bounding box of a pixbuf animation. * @returns Width of the bounding box of the animation. */ get_width(): number; /** * Checks whether the animation is a static image. * * If you load a file with gdk_pixbuf_animation_new_from_file() and it * turns out to be a plain, unanimated image, then this function will * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve * the image. * @returns `TRUE` if the "animation" was really just an image */ is_static_image(): boolean; // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation /** * Get an iterator for displaying an animation. * * The iterator provides the frames that should be displayed at a * given time. * * `start_time` would normally come from g_get_current_time(), and marks * the beginning of animation playback. After creating an iterator, you * should immediately display the pixbuf returned by * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install * a timeout (with g_timeout_add()) or by some other mechanism ensure * that you'll update the image after * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time * the image is updated, you should reinstall the timeout with the new, * possibly-changed delay time. * * As a shortcut, if `start_time` is `NULL`, the result of * g_get_current_time() will be used automatically. * * To update the image (i.e. possibly change the result of * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation), * call gdk_pixbuf_animation_iter_advance(). * * If you're using #GdkPixbufLoader, in addition to updating the image * after the delay time, you should also update it whenever you * receive the area_updated signal and * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns * `TRUE`. In this case, the frame currently being fed into the loader * has received new data, so needs to be refreshed. The delay time for * a frame may also be modified after an area_updated signal, for * example if the delay time for a frame is encoded in the data after * the frame itself. So your timeout should be reinstalled after any * area_updated signal. * * A delay time of -1 is possible, indicating "infinite". * @virtual * @param start_time time when the animation starts playing * @returns an iterator to move over the animation */ vfunc_get_iter(start_time: GLib.TimeVal | null): PixbufAnimationIter; vfunc_get_size(width: number, height: number): void; /** * Retrieves a static image for the animation. * * If an animation is really just a plain image (has only one frame), * this function returns that image. * * If the animation is an animation, this function returns a reasonable * image to use as a static unanimated image, which might be the first * frame, or something more sophisticated depending on the file format. * * If an animation hasn't loaded any frames yet, this function will * return `NULL`. * @virtual * @returns unanimated image representing the animation */ vfunc_get_static_image(): Pixbuf; /** * Checks whether the animation is a static image. * * If you load a file with gdk_pixbuf_animation_new_from_file() and it * turns out to be a plain, unanimated image, then this function will * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve * the image. * @virtual * @returns `TRUE` if the "animation" was really just an image */ vfunc_is_static_image(): boolean; // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } /** * 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. * @class */ class PixbufAnimation extends GObject.Object { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation constructor(config?: PixbufAnimation.ConstructorProperties); /** * Creates a new animation by loading it from a file. * * The file format is detected automatically. * * If the file's format does not support multi-frame images, then an animation * with a single frame will be created. * * Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains. * @constructor * @param filename Name of file to load, in the GLib file name encoding * @returns A newly-created animation */ static new_from_file(filename: string): PixbufAnimation; /** * Creates a new pixbuf animation by loading an image from an resource. * * The file format is detected automatically. If `NULL` is returned, then * `error` will be set. * @constructor * @param resource_path the path of the resource file * @returns A newly-created animation */ static new_from_resource(resource_path: string | null): PixbufAnimation; /** * Creates a new animation by loading it from an input stream. * * The file format is detected automatically. * * If `NULL` is returned, then `error` will be set. * * The `cancellable` can be used to abort the operation from another thread. * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and * `G_IO_ERROR` domains. * * The stream is not closed. * @constructor * @param stream a `GInputStream` to load the pixbuf from * @param cancellable optional `GCancellable` object * @returns A newly-created animation */ static new_from_stream( stream: Gio.InputStream, cancellable: Gio.Cancellable | null ): PixbufAnimation; /** * Finishes an asynchronous pixbuf animation creation operation started with * [func`GdkPixbuf`.PixbufAnimation.new_from_stream_async]. * @constructor * @param async_result a #GAsyncResult * @returns the newly created animation */ static new_from_stream_finish( async_result: Gio.AsyncResult ): PixbufAnimation; _init(config?: PixbufAnimation.ConstructorProperties): void; /** * Creates a new animation by asynchronously loading an image from an input stream. * * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous * version of this function. * * When the operation is finished, `callback` will be called in the main thread. * You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the * result of the operation. * @param stream a #GInputStream from which to load the animation * @param cancellable optional #GCancellable object * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded */ static new_from_stream_async( stream: Gio.InputStream, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null ): void; } module PixbufAnimationIter { // Constructor properties interface type ConstructorProperties = GObject.Object.ConstructorProperties; } interface PixbufAnimationIter { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter parent_instance: GObject.Object; // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter /** * Possibly advances an animation to a new frame. * * Chooses the frame based on the start time passed to * gdk_pixbuf_animation_get_iter(). * * `current_time` would normally come from g_get_current_time(), and * must be greater than or equal to the time passed to * gdk_pixbuf_animation_get_iter(), and must increase or remain * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is * called. That is, you can't go backward in time; animations only * play forward. * * As a shortcut, pass `NULL` for the current time and g_get_current_time() * will be invoked on your behalf. So you only need to explicitly pass * `current_time` if you're doing something odd like playing the animation * at double speed. * * If this function returns `FALSE`, there's no need to update the animation * display, assuming the display had been rendered prior to advancing; * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf() * and update the display with the new pixbuf. * @param current_time current time * @returns `TRUE` if the image may need updating */ advance(current_time: GLib.TimeVal | null): boolean; /** * Gets the number of milliseconds the current pixbuf should be displayed, * or -1 if the current pixbuf should be displayed forever. * * The `g_timeout_add()` function conveniently takes a timeout in milliseconds, * so you can use a timeout to schedule the next update. * * Note that some formats, like GIF, might clamp the timeout values in the * image file to avoid updates that are just too quick. The minimum timeout * for GIF images is currently 20 milliseconds. * @returns delay time in milliseconds (thousandths of a second) */ get_delay_time(): number; /** * Gets the current pixbuf which should be displayed. * * The pixbuf might not be the same size as the animation itself * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()). * * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time() * milliseconds. * * The caller of this function does not own a reference to the returned * pixbuf; the returned pixbuf will become invalid when the iterator * advances to the next frame, which may happen anytime you call * gdk_pixbuf_animation_iter_advance(). * * Copy the pixbuf to keep it (don't just add a reference), as it may get * recycled as you advance the iterator. * @returns the pixbuf to be displayed */ get_pixbuf(): Pixbuf; /** * Used to determine how to respond to the area_updated signal on * #GdkPixbufLoader when loading an animation. * * The `::area_updated` signal is emitted for an area of the frame currently * streaming in to the loader. So if you're on the currently loading frame, * you will need to redraw the screen for the updated area. * @returns `TRUE` if the frame we're on is partially loaded, or the last frame */ on_currently_loading_frame(): boolean; // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter /** * Possibly advances an animation to a new frame. * * Chooses the frame based on the start time passed to * gdk_pixbuf_animation_get_iter(). * * `current_time` would normally come from g_get_current_time(), and * must be greater than or equal to the time passed to * gdk_pixbuf_animation_get_iter(), and must increase or remain * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is * called. That is, you can't go backward in time; animations only * play forward. * * As a shortcut, pass `NULL` for the current time and g_get_current_time() * will be invoked on your behalf. So you only need to explicitly pass * `current_time` if you're doing something odd like playing the animation * at double speed. * * If this function returns `FALSE`, there's no need to update the animation * display, assuming the display had been rendered prior to advancing; * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf() * and update the display with the new pixbuf. * @virtual * @param current_time current time * @returns `TRUE` if the image may need updating */ vfunc_advance(current_time: GLib.TimeVal | null): boolean; /** * Gets the number of milliseconds the current pixbuf should be displayed, * or -1 if the current pixbuf should be displayed forever. * * The `g_timeout_add()` function conveniently takes a timeout in milliseconds, * so you can use a timeout to schedule the next update. * * Note that some formats, like GIF, might clamp the timeout values in the * image file to avoid updates that are just too quick. The minimum timeout * for GIF images is currently 20 milliseconds. * @virtual * @returns delay time in milliseconds (thousandths of a second) */ vfunc_get_delay_time(): number; /** * Gets the current pixbuf which should be displayed. * * The pixbuf might not be the same size as the animation itself * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()). * * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time() * milliseconds. * * The caller of this function does not own a reference to the returned * pixbuf; the returned pixbuf will become invalid when the iterator * advances to the next frame, which may happen anytime you call * gdk_pixbuf_animation_iter_advance(). * * Copy the pixbuf to keep it (don't just add a reference), as it may get * recycled as you advance the iterator. * @virtual * @returns the pixbuf to be displayed */ vfunc_get_pixbuf(): Pixbuf; /** * Used to determine how to respond to the area_updated signal on * #GdkPixbufLoader when loading an animation. * * The `::area_updated` signal is emitted for an area of the frame currently * streaming in to the loader. So if you're on the currently loading frame, * you will need to redraw the screen for the updated area. * @virtual * @returns `TRUE` if the frame we're on is partially loaded, or the last frame */ vfunc_on_currently_loading_frame(): boolean; // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } /** * An opaque object representing an iterator which points to a * certain position in an animation. * @class */ class PixbufAnimationIter extends GObject.Object { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter constructor(config?: PixbufAnimationIter.ConstructorProperties); _init(config?: PixbufAnimationIter.ConstructorProperties): void; } module PixbufLoader { // Signal callback interfaces /** * Signal callback interface for `area-prepared` */ interface AreaPreparedSignalCallback { ($obj: PixbufLoader): void; } /** * Signal callback interface for `area-updated` */ interface AreaUpdatedSignalCallback { ( $obj: PixbufLoader, x: number, y: number, width: number, height: number ): void; } /** * Signal callback interface for `closed` */ interface ClosedSignalCallback { ($obj: PixbufLoader): void; } /** * Signal callback interface for `size-prepared` */ interface SizePreparedSignalCallback { ($obj: PixbufLoader, width: number, height: number): void; } // Constructor properties interface type ConstructorProperties = GObject.Object.ConstructorProperties; } interface PixbufLoader { // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader /** * Informs a pixbuf loader that no further writes with * gdk_pixbuf_loader_write() will occur, so that it can free its * internal loading structures. * * This function also tries to parse any data that hasn't yet been parsed; * if the remaining data is partial or corrupt, an error will be returned. * * If `FALSE` is returned, `error` will be set to an error from the * `GDK_PIXBUF_ERROR` or `G_FILE_ERROR` domains. * * If you're just cancelling a load rather than expecting it to be finished, * passing `NULL` for `error` to ignore it is reasonable. * * Remember that this function does not release a reference on the loader, so * you will need to explicitly release any reference you hold. * @returns `TRUE` if all image data written so far was successfully passed out via the update_area signal */ close(): boolean; /** * Queries the #GdkPixbufAnimation that a pixbuf loader is currently creating. * * In general it only makes sense to call this function after the * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been emitted by * the loader. * * If the loader doesn't have enough bytes yet, and hasn't emitted the `area-prepared` * signal, this function will return `NULL`. * @returns The animation that the loader is currently loading */ get_animation(): PixbufAnimation | null; /** * Obtains the available information about the format of the * currently loading image file. * @returns A #GdkPixbufFormat */ get_format(): PixbufFormat | null; /** * Queries the #GdkPixbuf that a pixbuf loader is currently creating. * * In general it only makes sense to call this function after the * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been * emitted by the loader; this means that enough data has been read * to know the size of the image that will be allocated. * * If the loader has not received enough data via gdk_pixbuf_loader_write(), * then this function returns `NULL`. * * The returned pixbuf will be the same in all future calls to the loader, * so if you want to keep using it, you should acquire a reference to it. * * Additionally, if the loader is an animation, it will return the "static * image" of the animation (see gdk_pixbuf_animation_get_static_image()). * @returns The pixbuf that the loader is creating */ get_pixbuf(): Pixbuf | null; /** * Causes the image to be scaled while it is loaded. * * The desired image size can be determined relative to the original * size of the image by calling gdk_pixbuf_loader_set_size() from a * signal handler for the ::size-prepared signal. * * Attempts to set the desired image size are ignored after the * emission of the ::size-prepared signal. * @param width The desired width of the image being loaded. * @param height The desired height of the image being loaded. */ set_size(width: number, height: number): void; /** * Parses the next `count` bytes in the given image buffer. * @param buf Pointer to image data. * @returns `TRUE` if the write was successful, or `FALSE` if the loader cannot parse the buffer */ write(buf: Uint8Array): boolean; /** * Parses the next contents of the given image buffer. * @param buffer The image data as a `GBytes` buffer. * @returns `TRUE` if the write was successful, or `FALSE` if the loader cannot parse the buffer */ write_bytes(buffer: GLib.Bytes): boolean; // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader vfunc_area_prepared(): void; vfunc_area_updated( x: number, y: number, width: number, height: number ): void; vfunc_closed(): void; vfunc_size_prepared(width: number, height: number): void; // Own signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader connect( sigName: "area-prepared", callback: PixbufLoader.AreaPreparedSignalCallback ): number; connect_after( sigName: "area-prepared", callback: PixbufLoader.AreaPreparedSignalCallback ): number; emit(sigName: "area-prepared", ...args: any[]): void; connect( sigName: "area-updated", callback: PixbufLoader.AreaUpdatedSignalCallback ): number; connect_after( sigName: "area-updated", callback: PixbufLoader.AreaUpdatedSignalCallback ): number; emit( sigName: "area-updated", x: number, y: number, width: number, height: number, ...args: any[] ): void; connect( sigName: "closed", callback: PixbufLoader.ClosedSignalCallback ): number; connect_after( sigName: "closed", callback: PixbufLoader.ClosedSignalCallback ): number; emit(sigName: "closed", ...args: any[]): void; connect( sigName: "size-prepared", callback: PixbufLoader.SizePreparedSignalCallback ): number; connect_after( sigName: "size-prepared", callback: PixbufLoader.SizePreparedSignalCallback ): number; emit( sigName: "size-prepared", width: number, height: number, ...args: any[] ): void; // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } /** * Incremental image loader. * * `GdkPixbufLoader` provides a way for applications to drive the * process of loading an image, by letting them send the image data * directly to the loader instead of having the loader read the data * from a file. Applications can use this functionality instead of * `gdk_pixbuf_new_from_file()` or `gdk_pixbuf_animation_new_from_file()` * when they need to parse image data in small chunks. For example, * it should be used when reading an image from a (potentially) slow * network connection, or when loading an extremely large file. * * To use `GdkPixbufLoader` to load an image, create a new instance, * and call [method`GdkPixbuf`.PixbufLoader.write] to send the data * to it. When done, [method`GdkPixbuf`.PixbufLoader.close] should be * called to end the stream and finalize everything. * * The loader will emit three important signals throughout the process: * * - [signal`GdkPixbuf`.PixbufLoader::size-prepared] will be emitted as * soon as the image has enough information to determine the size of * the image to be used. If you want to scale the image while loading * it, you can call [method`GdkPixbuf`.PixbufLoader.set_size] in * response to this signal. * - [signal`GdkPixbuf`.PixbufLoader::area-prepared] will be emitted as * soon as the pixbuf of the desired has been allocated. You can obtain * the `GdkPixbuf` instance by calling [method`GdkPixbuf`.PixbufLoader.get_pixbuf]. * If you want to use it, simply acquire a reference to it. You can * also call `gdk_pixbuf_loader_get_pixbuf()` later to get the same * pixbuf. * - [signal`GdkPixbuf`.PixbufLoader::area-updated] will be emitted every * time a region is updated. This way you can update a partially * completed image. Note that you do not know anything about the * completeness of an image from the updated area. For example, in an * interlaced image you will need to make several passes before the * image is done loading. * * ## Loading an animation * * Loading an animation is almost as easy as loading an image. Once the * first [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been * emitted, you can call [method`GdkPixbuf`.PixbufLoader.get_animation] to * get the [class`GdkPixbuf`.PixbufAnimation] instance, and then call * and [method`GdkPixbuf`.PixbufAnimation.get_iter] to get a * [class`GdkPixbuf`.PixbufAnimationIter] to retrieve the pixbuf for the * desired time stamp. * @class */ class PixbufLoader extends GObject.Object { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader constructor(config?: PixbufLoader.ConstructorProperties); /** * Creates a new pixbuf loader object. * @constructor * @returns A newly-created pixbuf loader. */ constructor(); /** * Creates a new pixbuf loader object. * @constructor * @returns A newly-created pixbuf loader. */ static new(): PixbufLoader; /** * Creates a new pixbuf loader object that always attempts to parse * image data as if it were an image of MIME type `mime_type,` instead of * identifying the type automatically. * * This function is useful if you want an error if the image isn't the * expected MIME type; for loading image formats that can't be reliably * identified by looking at the data; or if the user manually forces a * specific MIME type. * * The list of supported mime types depends on what image loaders * are installed, but typically "image/png", "image/jpeg", "image/gif", * "image/tiff" and "image/x-xpixmap" are among the supported mime types. * To obtain the full list of supported mime types, call * gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat * structs returned by gdk_pixbuf_get_formats(). * @constructor * @param mime_type the mime type to be loaded * @returns A newly-created pixbuf loader. */ static new_with_mime_type(mime_type: string | null): PixbufLoader; /** * Creates a new pixbuf loader object that always attempts to parse * image data as if it were an image of type `image_type,` instead of * identifying the type automatically. * * This function is useful if you want an error if the image isn't the * expected type; for loading image formats that can't be reliably * identified by looking at the data; or if the user manually forces * a specific type. * * The list of supported image formats depends on what image loaders * are installed, but typically "png", "jpeg", "gif", "tiff" and * "xpm" are among the supported formats. To obtain the full list of * supported image formats, call gdk_pixbuf_format_get_name() on each * of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats(). * @constructor * @param image_type name of the image format to be loaded with the image * @returns A newly-created pixbuf loader. */ static new_with_type(image_type: string | null): PixbufLoader; _init(config?: PixbufLoader.ConstructorProperties): void; } module PixbufNonAnim { // Constructor properties interface type ConstructorProperties = PixbufAnimation.ConstructorProperties; } interface PixbufNonAnim { // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } class PixbufNonAnim extends PixbufAnimation { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim constructor(config?: PixbufNonAnim.ConstructorProperties); constructor(pixbuf: Pixbuf); static new(pixbuf: Pixbuf): PixbufNonAnim; _init(config?: PixbufNonAnim.ConstructorProperties): void; } module PixbufSimpleAnim { // Constructor properties interface interface ConstructorProperties extends PixbufAnimation.ConstructorProperties { // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim /** * Whether the animation should loop when it reaches the end. */ loop?: boolean | null; } } interface PixbufSimpleAnim { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim /** * Whether the animation should loop when it reaches the end. */ loop: boolean; // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim /** * Adds a new frame to `animation`. The `pixbuf` must * have the dimensions specified when the animation * was constructed. * @param pixbuf the pixbuf to add */ add_frame(pixbuf: Pixbuf): void; /** * Gets whether `animation` should loop indefinitely when it reaches the end. * @returns %TRUE if the animation loops forever, %FALSE otherwise */ get_loop(): boolean; /** * Sets whether `animation` should loop indefinitely when it reaches the end. * @param loop whether to loop the animation */ set_loop(loop: boolean): void; // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim connect( sigName: "notify::loop", callback: ($obj: PixbufSimpleAnim, pspec: GObject.ParamSpec) => void ): number; connect_after( sigName: "notify::loop", callback: ($obj: PixbufSimpleAnim, pspec: GObject.ParamSpec) => void ): number; emit(sigName: "notify::loop", ...args: any[]): void; connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } /** * An opaque struct representing a simple animation. * @class */ class PixbufSimpleAnim extends PixbufAnimation { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim constructor(config?: PixbufSimpleAnim.ConstructorProperties); /** * Creates a new, empty animation. * @constructor * @param width the width of the animation * @param height the height of the animation * @param rate the speed of the animation, in frames per second * @returns a newly allocated #GdkPixbufSimpleAnim */ constructor(width: number, height: number, rate: number); /** * Creates a new, empty animation. * @constructor * @param width the width of the animation * @param height the height of the animation * @param rate the speed of the animation, in frames per second * @returns a newly allocated #GdkPixbufSimpleAnim */ static new(width: number, height: number, rate: number): PixbufSimpleAnim; _init(config?: PixbufSimpleAnim.ConstructorProperties): void; } module PixbufSimpleAnimIter { // Constructor properties interface type ConstructorProperties = PixbufAnimationIter.ConstructorProperties; } interface PixbufSimpleAnimIter { // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter connect(sigName: string, callback: (...args: any[]) => void): number; connect_after(sigName: string, callback: (...args: any[]) => void): number; emit(sigName: string, ...args: any[]): void; disconnect(id: number): void; } class PixbufSimpleAnimIter extends PixbufAnimationIter { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter static name: string; static $gtype: GObject.GType; // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter constructor(config?: PixbufSimpleAnimIter.ConstructorProperties); _init(config?: PixbufSimpleAnimIter.ConstructorProperties): void; } interface PixbufAnimationClass { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass /** * the parent class * @field */ parent_class: GObject.ObjectClass; is_static_image: (animation: PixbufAnimation) => boolean; get_static_image: (animation: PixbufAnimation) => Pixbuf; get_size: ( animation: PixbufAnimation, width: number, height: number ) => void; get_iter: ( animation: PixbufAnimation, start_time: GLib.TimeVal | null ) => PixbufAnimationIter; } /** * Modules supporting animations must derive a type from * #GdkPixbufAnimation, providing suitable implementations of the * virtual functions. * @record */ abstract class PixbufAnimationClass { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass static name: string; } interface PixbufAnimationIterClass { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass /** * the parent class * @field */ parent_class: GObject.ObjectClass; get_delay_time: (iter: PixbufAnimationIter) => number; get_pixbuf: (iter: PixbufAnimationIter) => Pixbuf; on_currently_loading_frame: (iter: PixbufAnimationIter) => boolean; advance: ( iter: PixbufAnimationIter, current_time: GLib.TimeVal | null ) => boolean; } /** * Modules supporting animations must derive a type from * #GdkPixbufAnimationIter, providing suitable implementations of the * virtual functions. * @record */ abstract class PixbufAnimationIterClass { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass static name: string; } interface PixbufFormat { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat /** * the name of the image format * @field */ name: string | null; /** * the signature of the module * @field */ signature: PixbufModulePattern; /** * the message domain for the `description` * @field */ domain: string | null; /** * a description of the image format * @field */ description: string | null; /** * the MIME types for the image format * @field */ mime_types: string[]; /** * typical filename extensions for the * image format * @field */ extensions: string[]; /** * a combination of `GdkPixbufFormatFlags` * @field */ flags: number; /** * a boolean determining whether the loader is disabled` * @field */ disabled: boolean; /** * a string containing license information, typically set to * shorthands like "GPL", "LGPL", etc. * @field */ license: string | null; // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat /** * Creates a copy of `format`. * @returns the newly allocated copy of a `GdkPixbufFormat`. Use gdk_pixbuf_format_free() to free the resources when done */ copy(): PixbufFormat; /** * Frees the resources allocated when copying a `GdkPixbufFormat` * using gdk_pixbuf_format_copy() */ free(): void; /** * Returns a description of the format. * @returns a description of the format. */ get_description(): string | null; /** * Returns the filename extensions typically used for files in the * given format. * @returns an array of filename extensions */ get_extensions(): string[]; /** * Returns information about the license of the image loader for the format. * * The returned string should be a shorthand for a well known license, e.g. * "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license. * @returns a string describing the license of the pixbuf format */ get_license(): string | null; /** * Returns the mime types supported by the format. * @returns an array of mime types */ get_mime_types(): string[]; /** * Returns the name of the format. * @returns the name of the format. */ get_name(): string | null; /** * Returns whether this image format is disabled. * * See gdk_pixbuf_format_set_disabled(). * @returns whether this image format is disabled. */ is_disabled(): boolean; /** * Returns `TRUE` if the save option specified by `option_key` is supported when * saving a pixbuf using the module implementing `format`. * * See gdk_pixbuf_save() for more information about option keys. * @param option_key the name of an option * @returns `TRUE` if the specified option is supported */ is_save_option_supported(option_key: string | null): boolean; /** * Returns whether this image format is scalable. * * If a file is in a scalable format, it is preferable to load it at * the desired size, rather than loading it at the default size and * scaling the resulting pixbuf to the desired size. * @returns whether this image format is scalable. */ is_scalable(): boolean; /** * Returns whether pixbufs can be saved in the given format. * @returns whether pixbufs can be saved in the given format. */ is_writable(): boolean; /** * Disables or enables an image format. * * If a format is disabled, GdkPixbuf won't use the image loader for * this format to load images. * * Applications can use this to avoid using image loaders with an * inappropriate license, see gdk_pixbuf_format_get_license(). * @param disabled `TRUE` to disable the format `format` */ set_disabled(disabled: boolean): void; } /** * A `GdkPixbufFormat` contains information about the image format accepted * by a module. * * Only modules should access the fields directly, applications should * use the `gdk_pixbuf_format_*` family of functions. * @record */ class PixbufFormat { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat static name: string; } interface PixbufLoaderClass { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass parent_class: GObject.ObjectClass; size_prepared: ( loader: PixbufLoader, width: number, height: number ) => void; area_prepared: (loader: PixbufLoader) => void; area_updated: ( loader: PixbufLoader, x: number, y: number, width: number, height: number ) => void; closed: (loader: PixbufLoader) => void; } abstract class PixbufLoaderClass { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass static name: string; } interface PixbufModule { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModule /** * the name of the module, usually the same as the * usual file extension for images of this type, eg. "xpm", "jpeg" or "png". * @field */ module_name: string | null; /** * the path from which the module is loaded. * @field */ module_path: string | null; /** * the loaded `GModule`. * @field */ module: GModule.Module; /** * a `GdkPixbufFormat` holding information about the module. * @field */ info: PixbufFormat; /** * loads an image from a file. * @field */ load: PixbufModuleLoadFunc; /** * loads an image from data in memory. * @field */ load_xpm_data: PixbufModuleLoadXpmDataFunc; /** * stops an incremental load. * @field */ stop_load: PixbufModuleStopLoadFunc; /** * continues an incremental load. * @field */ load_increment: PixbufModuleIncrementLoadFunc; /** * loads an animation from a file. * @field */ load_animation: PixbufModuleLoadAnimationFunc; /** * saves a `GdkPixbuf` to a file. * @field */ save: PixbufModuleSaveFunc; /** * returns whether a save option key is supported by the module * @field */ is_save_option_supported: PixbufModuleSaveOptionSupportedFunc; } /** * A `GdkPixbufModule` contains the necessary functions to load and save * images in a certain file format. * * If `GdkPixbuf` has been compiled with `GModule` support, it can be extended * by modules which can load (and perhaps also save) new image and animation * formats. * * ## Implementing modules * * The `GdkPixbuf` interfaces needed for implementing modules are contained in * `gdk-pixbuf-io.h` (and `gdk-pixbuf-animation.h` if the module supports * animations). They are not covered by the same stability guarantees as the * regular GdkPixbuf API. To underline this fact, they are protected by the * `GDK_PIXBUF_ENABLE_BACKEND` pre-processor symbol. * * Each loadable module must contain a `GdkPixbufModuleFillVtableFunc` function * named `fill_vtable`, which will get called when the module * is loaded and must set the function pointers of the `GdkPixbufModule`. * * In order to make format-checking work before actually loading the modules * (which may require calling `dlopen` to load image libraries), modules export * their signatures (and other information) via the `fill_info` function. An * external utility, `gdk-pixbuf-query-loaders`, uses this to create a text * file containing a list of all available loaders and their signatures. * This file is then read at runtime by `GdkPixbuf` to obtain the list of * available loaders and their signatures. * * Modules may only implement a subset of the functionality available via * `GdkPixbufModule`. If a particular functionality is not implemented, the * `fill_vtable` function will simply not set the corresponding * function pointers of the `GdkPixbufModule` structure. If a module supports * incremental loading (i.e. provides `begin_load`, `stop_load` and * `load_increment`), it doesn't have to implement `load`, since `GdkPixbuf` * can supply a generic `load` implementation wrapping the incremental loading. * * ## Installing modules * * Installing a module is a two-step process: * * - copy the module file(s) to the loader directory (normally * `$libdir/gdk-pixbuf-2.0/$version/loaders`, unless overridden by the * environment variable `GDK_PIXBUF_MODULEDIR`) * - call `gdk-pixbuf-query-loaders` to update the module file (normally * `$libdir/gdk-pixbuf-2.0/$version/loaders.cache`, unless overridden * by the environment variable `GDK_PIXBUF_MODULE_FILE`) * @record */ class PixbufModule { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModule static name: string; } interface PixbufModulePattern { // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern /** * the prefix for this pattern * @field */ prefix: string | null; /** * mask containing bytes which modify how the prefix is matched against * test data * @field */ mask: string | null; /** * relevance of this pattern * @field */ relevance: number; } /** * The signature prefix for a module. * * The signature of a module is a set of prefixes. Prefixes are encoded as * pairs of ordinary strings, where the second string, called the mask, if * not `NULL`, must be of the same length as the first one and may contain * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched, * not matched, "don't-care"-bytes, zeros and non-zeros, respectively. * * Each prefix has an associated integer that describes the relevance of * the prefix, with 0 meaning a mismatch and 100 a "perfect match". * * Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*', * indicating an unanchored pattern that matches not only at the beginning, * but also in the middle. Versions prior to 2.8 will interpret the '*' * like an 'x'. * * The signature of a module is stored as an array of * `GdkPixbufModulePatterns`. The array is terminated by a pattern * where the `prefix` is `NULL`. * * ```c * GdkPixbufModulePattern *signature[] = { * { "abcdx", " !x z", 100 }, * { "bla", NULL, 90 }, * { NULL, NULL, 0 } * }; * ``` * * In the example above, the signature matches e.g. "auud\0" with * relevance 100, and "blau" with relevance 90. * @record */ class PixbufModulePattern { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern static name: string; } interface PixbufSimpleAnimClass {} abstract class PixbufSimpleAnimClass { // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimClass static name: string; } /** * Name of the imported GIR library * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188 */ const __name__: string; /** * Version of the imported GIR library * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189 */ const __version__: string; }