Package ch.bailu.gtk.gdkpixbuf

Class Pixbuf

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gdkpixbuf.Pixbuf
All Implemented Interfaces:
PointerInterface
public class Pixbuf extends Object
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.

https://docs.gtk.org/gdk-pixbuf/class.Pixbuf.html

  • Constructor Details

    • Pixbuf

      public Pixbuf(PointerContainer pointer)

    • Pixbuf

      public Pixbuf(int colorspace, boolean has_alpha, int bits_per_sample, int width, int height)
      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.
      Parameters:
      colorspace - Color space for image
      has_alpha - Whether the image should have transparency information
      bits_per_sample - Number of bits per color sample
      width - Width of image in pixels, must be > 0
      height - Height of image in pixels, must be > 0

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newFromBytesPixbuf

      public static Pixbuf newFromBytesPixbuf(@Nonnull Bytes data, int colorspace, boolean has_alpha, int bits_per_sample, int width, int height, int rowstride)
      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.
      Parameters:
      data - Image data in 8-bit/sample packed format inside a #GBytes
      colorspace - Colorspace for the image data
      has_alpha - Whether the data has an opacity channel
      bits_per_sample - Number of bits per sample
      width - Width of the image in pixels, must be > 0
      height - Height of the image in pixels, must be > 0
      rowstride - Distance in bytes between row starts
      Returns:
      A newly-created pixbuf

    • newFromFilePixbuf

      public static Pixbuf newFromFilePixbuf(@Nonnull Str filename) throws AllocationError
      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`.
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromFilePixbuf

      public static Pixbuf newFromFilePixbuf(String filename) throws AllocationError
      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`.
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromFileAtScalePixbuf

      public static Pixbuf newFromFileAtScalePixbuf(@Nonnull Str filename, int width, int height, boolean preserve_aspect_ratio) throws AllocationError
      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.
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromFileAtScalePixbuf

      public static Pixbuf newFromFileAtScalePixbuf(String filename, int width, int height, boolean preserve_aspect_ratio) throws AllocationError
      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.
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromFileAtSizePixbuf

      public static Pixbuf newFromFileAtSizePixbuf(@Nonnull Str filename, int width, int height) throws AllocationError
      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].
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromFileAtSizePixbuf

      public static Pixbuf newFromFileAtSizePixbuf(String filename, int width, int height) throws AllocationError
      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].
      Parameters:
      filename - Name of file to load, in the GLib file name encoding
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromResourcePixbuf

      public static Pixbuf newFromResourcePixbuf(@Nonnull Str resource_path) throws AllocationError
      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.
      Parameters:
      resource_path - the path of the resource file
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromResourcePixbuf

      public static Pixbuf newFromResourcePixbuf(String resource_path) throws AllocationError
      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.
      Parameters:
      resource_path - the path of the resource file
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromResourceAtScalePixbuf

      public static Pixbuf newFromResourceAtScalePixbuf(@Nonnull Str resource_path, int width, int height, boolean preserve_aspect_ratio) throws AllocationError
      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.
      Parameters:
      resource_path - the path of the resource file
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromResourceAtScalePixbuf

      public static Pixbuf newFromResourceAtScalePixbuf(String resource_path, int width, int height, boolean preserve_aspect_ratio) throws AllocationError
      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.
      Parameters:
      resource_path - the path of the resource file
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromStreamPixbuf

      public static Pixbuf newFromStreamPixbuf(@Nonnull InputStream stream, @Nullable Cancellable cancellable) throws AllocationError
      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.
      Parameters:
      stream - a `GInputStream` to load the pixbuf from
      cancellable - optional `GCancellable` object, `NULL` to ignore
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromStreamAtScalePixbuf

      public static Pixbuf newFromStreamAtScalePixbuf(@Nonnull InputStream stream, int width, int height, boolean preserve_aspect_ratio, @Nullable Cancellable cancellable) throws AllocationError
      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.
      Parameters:
      stream - a `GInputStream` to load the pixbuf from
      width - The width the image should have or -1 to not constrain the width
      height - The height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      cancellable - optional `GCancellable` object, `NULL` to ignore
      Returns:
      A newly-created pixbuf
      Throws:
      AllocationError

    • newFromStreamFinishPixbuf

      public static Pixbuf newFromStreamFinishPixbuf(@Nonnull AsyncResult async_result) throws AllocationError
      Finishes an asynchronous pixbuf creation operation started with
      gdk_pixbuf_new_from_stream_async().
      Parameters:
      async_result - a `GAsyncResult`
      Returns:
      the newly created pixbuf
      Throws:
      AllocationError

    • newFromXpmDataPixbuf

      public static Pixbuf newFromXpmDataPixbuf(@Nonnull Strs data)
      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.
      Parameters:
      data - Pointer to inline XPM data.
      Returns:
      A newly-created pixbuf

    • applyEmbeddedOrientation

      public Pixbuf applyEmbeddedOrientation()
      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

    • composite

      public void composite(@Nonnull Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, int interp_type, int overall_alpha)
      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)
      Parameters:
      dest - the #GdkPixbuf into which to render the results
      dest_x - the left coordinate for region to render
      dest_y - the top coordinate for region to render
      dest_width - the width of the region to render
      dest_height - the height of the region to render
      offset_x - the offset in the X direction (currently rounded to an integer)
      offset_y - the offset in the Y direction (currently rounded to an integer)
      scale_x - the scale factor in the X direction
      scale_y - the scale factor in the Y direction
      interp_type - the interpolation type for the transformation.
      overall_alpha - overall alpha for source image (0..255)

    • compositeColor

      public void compositeColor(@Nonnull Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, int interp_type, int overall_alpha, int check_x, int check_y, int check_size, int color1, int color2)
      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.
      Parameters:
      dest - the #GdkPixbuf into which to render the results
      dest_x - the left coordinate for region to render
      dest_y - the top coordinate for region to render
      dest_width - the width of the region to render
      dest_height - the height of the region to render
      offset_x - the offset in the X direction (currently rounded to an integer)
      offset_y - the offset in the Y direction (currently rounded to an integer)
      scale_x - the scale factor in the X direction
      scale_y - the scale factor in the Y direction
      interp_type - the interpolation type for the transformation.
      overall_alpha - overall alpha for source image (0..255)
      check_x - the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
      check_y - the Y offset for the checkboard
      check_size - the size of checks in the checkboard (must be a power of two)
      color1 - the color of check at upper left
      color2 - the color of the other check

    • compositeColorSimple

      public Pixbuf compositeColorSimple(int dest_width, int dest_height, int interp_type, int overall_alpha, int check_size, int color1, int color2)
      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`.
      Parameters:
      dest_width - the width of destination image
      dest_height - the height of destination image
      interp_type - the interpolation type for the transformation.
      overall_alpha - overall alpha for source image (0..255)
      check_size - the size of checks in the checkboard (must be a power of two)
      color1 - the color of check at upper left
      color2 - the color of the other check
      Returns:
      the new pixbuf

    • copy

      public Pixbuf copy()
      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

    • copyArea

      public void copyArea(int src_x, int src_y, int width, int height, @Nonnull Pixbuf dest_pixbuf, int dest_x, int dest_y)
      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.
      Parameters:
      src_x - Source X coordinate within @src_pixbuf.
      src_y - Source Y coordinate within @src_pixbuf.
      width - Width of the area to copy.
      height - Height of the area to copy.
      dest_pixbuf - Destination pixbuf.
      dest_x - X coordinate within @dest_pixbuf.
      dest_y - Y coordinate within @dest_pixbuf.

    • copyOptions

      public boolean copyOptions(@Nonnull Pixbuf dest_pixbuf)
      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.
      Parameters:
      dest_pixbuf - the destination pixbuf
      Returns:
      `TRUE` on success.

    • fill

      public void fill(int pixel)
      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.
      Parameters:
      pixel - RGBA pixel to used to clear (`0xffffffff` is opaque white, `0x00000000` transparent black)

    • flip

      public Pixbuf flip(boolean horizontal)
      Flips a pixbuf horizontally or vertically and returns the
      result in a new pixbuf.
      Parameters:
      horizontal - `TRUE` to flip horizontally, `FALSE` to flip vertically
      Returns:
      the new pixbuf

    • getBitsPerSample

      public int getBitsPerSample()
      Queries the number of bits per color sample in a pixbuf.
      Returns:
      Number of bits per color sample.

    • getByteLength

      public long getByteLength()
      Returns the length of the pixel data, in bytes.
      Returns:
      The length of the pixel data.

    • getColorspace

      public int getColorspace()
      Queries the color space of a pixbuf.
      Returns:
      Color space.

    • getHasAlpha

      public boolean getHasAlpha()
      Queries whether a pixbuf has an alpha channel (opacity information).
      Returns:
      `TRUE` if it has an alpha channel, `FALSE` otherwise.

    • getHeight

      public int getHeight()
      Queries the height of a pixbuf.
      Returns:
      Height in pixels.

    • getNChannels

      public int getNChannels()
      Queries the number of channels of a pixbuf.
      Returns:
      Number of channels.

    • getOption

      public Str getOption(@Nonnull Str key)
      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.
      Parameters:
      key - a nul-terminated string.
      Returns:
      the value associated with `key`

    • getOption

      public Str getOption(String key)
      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.
      Parameters:
      key - a nul-terminated string.
      Returns:
      the value associated with `key`

    • getOptions

      public HashTable getOptions()
      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

    • getRowstride

      public int getRowstride()
      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.

    • getWidth

      public int getWidth()
      Queries the width of a pixbuf.
      Returns:
      Width in pixels.

    • newSubpixbuf

      public Pixbuf newSubpixbuf(int src_x, int src_y, int width, int height)
      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.
      Parameters:
      src_x - X coord in @src_pixbuf
      src_y - Y coord in @src_pixbuf
      width - width of region in @src_pixbuf
      height - height of region in @src_pixbuf
      Returns:
      a new pixbuf

    • readPixelBytes

      public Bytes readPixelBytes()
      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.

    • removeOption

      public boolean removeOption(@Nonnull Str key)
      Removes the key/value pair option attached to a `GdkPixbuf`.
      Parameters:
      key - a nul-terminated string representing the key to remove.
      Returns:
      `TRUE` if an option was removed, `FALSE` if not.

    • removeOption

      public boolean removeOption(String key)
      Removes the key/value pair option attached to a `GdkPixbuf`.
      Parameters:
      key - a nul-terminated string representing the key to remove.
      Returns:
      `TRUE` if an option was removed, `FALSE` if not.

    • rotateSimple

      public Pixbuf rotateSimple(int angle)
      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`.
      Parameters:
      angle - the angle to rotate by
      Returns:
      the new pixbuf

    • saturateAndPixelate

      public void saturateAndPixelate(@Nonnull Pixbuf dest, float saturation, boolean pixelate)
      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.
      Parameters:
      dest - place to write modified version of @src
      saturation - saturation factor
      pixelate - whether to pixelate

    • saveToStreamAsync

      public void saveToStreamAsync(@Nonnull OutputStream stream, @Nonnull Str type, @Nullable Cancellable cancellable, Pixbuf.OnAsyncReadyCallback callback, @Nullable Pointer user_data, Object... _elipse)
      Saves `pixbuf` to an output stream asynchronously.

      For more details see gdk_pixbuf_save_to_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_save_to_stream_finish() to get the result of
      the operation.
      Parameters:
      stream - a `GOutputStream` to which to save the pixbuf
      type - name of file format
      cancellable - optional `GCancellable` object, `NULL` to ignore
      callback - a `GAsyncReadyCallback` to call when the pixbuf is saved
      user_data - the data to pass to the callback function
      _elipse - list of key-value save options

    • saveToStreamAsync

      public void saveToStreamAsync(@Nonnull OutputStream stream, String type, @Nullable Cancellable cancellable, Pixbuf.OnAsyncReadyCallback callback, @Nullable Pointer user_data, Object... _elipse)
      Saves `pixbuf` to an output stream asynchronously.

      For more details see gdk_pixbuf_save_to_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_save_to_stream_finish() to get the result of
      the operation.
      Parameters:
      stream - a `GOutputStream` to which to save the pixbuf
      type - name of file format
      cancellable - optional `GCancellable` object, `NULL` to ignore
      callback - a `GAsyncReadyCallback` to call when the pixbuf is saved
      user_data - the data to pass to the callback function
      _elipse - list of key-value save options

    • saveToStreamv

      public boolean saveToStreamv(@Nonnull OutputStream stream, @Nonnull Str type, @Nullable Strs option_keys, @Nullable Strs option_values, @Nullable Cancellable cancellable) throws AllocationError
      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.
      Parameters:
      stream - a `GOutputStream` to save the pixbuf to
      type - name of file format
      option_keys - name of options to set
      option_values - values for named options
      cancellable - optional `GCancellable` object, `NULL` to ignore
      Returns:
      `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
      Throws:
      AllocationError

    • saveToStreamv

      public boolean saveToStreamv(@Nonnull OutputStream stream, String type, @Nullable Strs option_keys, @Nullable Strs option_values, @Nullable Cancellable cancellable) throws AllocationError
      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.
      Parameters:
      stream - a `GOutputStream` to save the pixbuf to
      type - name of file format
      option_keys - name of options to set
      option_values - values for named options
      cancellable - optional `GCancellable` object, `NULL` to ignore
      Returns:
      `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
      Throws:
      AllocationError

    • savev

      public boolean savev(@Nonnull Str filename, @Nonnull Str type, @Nullable Strs option_keys, @Nullable Strs option_values) throws AllocationError
      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.
      Parameters:
      filename - name of file to save.
      type - name of file format.
      option_keys - name of options to set
      option_values - values for named options
      Returns:
      whether an error was set
      Throws:
      AllocationError

    • savev

      public boolean savev(String filename, String type, @Nullable Strs option_keys, @Nullable Strs option_values) throws AllocationError
      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.
      Parameters:
      filename - name of file to save.
      type - name of file format.
      option_keys - name of options to set
      option_values - values for named options
      Returns:
      whether an error was set
      Throws:
      AllocationError

    • scale

      public void scale(@Nonnull Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, int interp_type)
      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.
      Parameters:
      dest - the #GdkPixbuf into which to render the results
      dest_x - the left coordinate for region to render
      dest_y - the top coordinate for region to render
      dest_width - the width of the region to render
      dest_height - the height of the region to render
      offset_x - the offset in the X direction (currently rounded to an integer)
      offset_y - the offset in the Y direction (currently rounded to an integer)
      scale_x - the scale factor in the X direction
      scale_y - the scale factor in the Y direction
      interp_type - the interpolation type for the transformation.

    • scaleSimple

      public Pixbuf scaleSimple(int dest_width, int dest_height, int interp_type)
      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].
      Parameters:
      dest_width - the width of destination image
      dest_height - the height of destination image
      interp_type - the interpolation type for the transformation.
      Returns:
      the new pixbuf

    • setOption

      public boolean setOption(@Nonnull Str key, @Nonnull Str value)
      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.
      Parameters:
      key - a nul-terminated string.
      value - a nul-terminated string.
      Returns:
      `TRUE` on success

    • setOption

      public boolean setOption(String key, String value)
      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.
      Parameters:
      key - a nul-terminated string.
      value - a nul-terminated string.
      Returns:
      `TRUE` on success

    • calculateRowstride

      public static int calculateRowstride(int colorspace, boolean has_alpha, int bits_per_sample, int width, int height)
      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`.
      Parameters:
      colorspace - Color space for image
      has_alpha - Whether the image should have transparency information
      bits_per_sample - Number of bits per color sample
      width - Width of image in pixels, must be > 0
      height - Height of image in pixels, must be > 0
      Returns:
      the rowstride for the given values, or -1 in case of error.

    • getFileInfo

      public static PixbufFormat getFileInfo(@Nonnull Str filename, @Nullable Int width, @Nullable Int height)
      Parses an image file far enough to determine its format and size.
      Parameters:
      filename - The name of the file to identify.
      width - Return location for the width of the image
      height - Return location for the height of the image
      Returns:
      A `GdkPixbufFormat` describing the image format of the file

    • getFileInfoAsync

      public static void getFileInfoAsync(@Nonnull Str filename, @Nullable Cancellable cancellable, Pixbuf.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      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.
      Parameters:
      filename - The name of the file to identify
      cancellable - optional `GCancellable` object, `NULL` to ignore
      callback - a `GAsyncReadyCallback` to call when the file info is available
      user_data - the data to pass to the callback function

    • getFileInfoFinish

      public static PixbufFormat getFileInfoFinish(@Nonnull AsyncResult async_result, @Nonnull Int width, @Nonnull Int height) throws AllocationError
      Finishes an asynchronous pixbuf parsing operation started with
      gdk_pixbuf_get_file_info_async().
      Parameters:
      async_result - a `GAsyncResult`
      width - Return location for the width of the image, or `NULL`
      height - Return location for the height of the image, or `NULL`
      Returns:
      A `GdkPixbufFormat` describing the image format of the file
      Throws:
      AllocationError

    • getFormats

      public static SList getFormats()
      Obtains the available information about the image formats supported
      by GdkPixbuf.
      Returns:
      A list of support image formats.

    • initModules

      public static boolean initModules(@Nonnull Str path) throws AllocationError
      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.
      Parameters:
      path - Path to directory where the `loaders.cache` is installed
      Returns:
      Throws:
      AllocationError

    • newFromStreamAsync

      public static void newFromStreamAsync(@Nonnull InputStream stream, @Nullable Cancellable cancellable, Pixbuf.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      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.
      Parameters:
      stream - a `GInputStream` from which to load the pixbuf
      cancellable - optional `GCancellable` object, `NULL` to ignore
      callback - a `GAsyncReadyCallback` to call when the pixbuf is loaded
      user_data - the data to pass to the callback function

    • newFromStreamAtScaleAsync

      public static void newFromStreamAtScaleAsync(@Nonnull InputStream stream, int width, int height, boolean preserve_aspect_ratio, @Nullable Cancellable cancellable, Pixbuf.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      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.
      Parameters:
      stream - a `GInputStream` from which to load the pixbuf
      width - the width the image should have or -1 to not constrain the width
      height - the height the image should have or -1 to not constrain the height
      preserve_aspect_ratio - `TRUE` to preserve the image's aspect ratio
      cancellable - optional `GCancellable` object, `NULL` to ignore
      callback - a `GAsyncReadyCallback` to call when the pixbuf is loaded
      user_data - the data to pass to the callback function

    • saveToStreamFinish

      public static boolean saveToStreamFinish(@Nonnull AsyncResult async_result) throws AllocationError
      Finishes an asynchronous pixbuf save operation started with
      gdk_pixbuf_save_to_stream_async().
      Parameters:
      async_result - a `GAsyncResult`
      Returns:
      `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
      Throws:
      AllocationError

    • asIcon

      public Icon asIcon()
      Implements interface Icon. Call this to get access to interface functions.
      Returns:
      Icon

    • asLoadableIcon

      public LoadableIcon asLoadableIcon()
      Implements interface LoadableIcon. Call this to get access to interface functions.
      Returns:
      LoadableIcon

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()