gimp/libgimp/gimpimage_pdb.c

/* LIBGIMP - The GIMP Library
 * Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
 *
 * gimpimage_pdb.c
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <https://www.gnu.org/licenses/>.
 */

/* NOTE: This file is auto-generated by pdbgen.pl */

#include "config.h"

#include "gimp.h"


/**
 * SECTION: gimpimage
 * @title: gimpimage
 * @short_description: Operations on complete images.
 *
 * Operations on complete images: creation, resizing/rescaling, and
 * operations involving multiple layers.
 **/


/**
 * gimp_image_id_is_valid:
 * @image_id: The image ID to check.
 *
 * Returns TRUE if the image ID is valid.
 *
 * This procedure checks if the given image ID is valid and refers to
 * an existing image.
 *
 * Returns: Whether the image ID is valid.
 *
 * Since: 3.0
 **/
gboolean
gimp_image_id_is_valid (gint image_id)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean valid = FALSE;

  args = gimp_value_array_new_from_types (NULL,
                                          G_TYPE_INT, image_id,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-id-is-valid",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    valid = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return valid;
}

/**
 * gimp_get_images:
 * @num_images: (out): The number of images currently open.
 *
 * Returns the list of images currently open.
 *
 * This procedure returns the list of images currently open in GIMP.
 *
 * Returns: (array length=num_images) (element-type GimpImage) (transfer container):
 *          The list of images currently open.
 *          The returned value must be freed with g_free().
 **/
GimpImage **
gimp_get_images (gint *num_images)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpImage **images = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-get-images",
                                              args);
  gimp_value_array_unref (args);

  *num_images = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_images = GIMP_VALUES_GET_INT (return_vals, 1);
      { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) images = g_memdup (a->data, a->length * sizeof (gpointer)); };
    }

  gimp_value_array_unref (return_vals);

  return images;
}

/**
 * gimp_image_new:
 * @width: The width of the image.
 * @height: The height of the image.
 * @type: The type of image.
 *
 * Creates a new image with the specified width, height, and type.
 *
 * Creates a new image, undisplayed, with the specified extents and
 * type. A layer should be created and added before this image is
 * displayed, or subsequent calls to gimp_display_new() with this image
 * as an argument will fail. Layers can be created using the
 * gimp_layer_new() commands. They can be added to an image using the
 * gimp_image_insert_layer() command.
 *
 * If your image's type if INDEXED, a colormap must also be added with
 * gimp_image_set_colormap(). An indexed image without a colormap will
 * output unexpected colors.
 *
 * Returns: (transfer none): The newly created image.
 **/
GimpImage *
gimp_image_new (gint              width,
                gint              height,
                GimpImageBaseType type)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpImage *image = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          G_TYPE_INT, width,
                                          G_TYPE_INT, height,
                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-new",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    image = GIMP_VALUES_GET_IMAGE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return image;
}

/**
 * gimp_image_new_with_precision:
 * @width: The width of the image.
 * @height: The height of the image.
 * @type: The type of image.
 * @precision: The precision.
 *
 * Creates a new image with the specified width, height, type and
 * precision.
 *
 * Creates a new image, undisplayed with the specified extents, type
 * and precision. Indexed images can only be created at
 * GIMP_PRECISION_U8_NON_LINEAR precision. See gimp_image_new() for
 * further details.
 *
 * Returns: (transfer none): The newly created image.
 *
 * Since: 2.10
 **/
GimpImage *
gimp_image_new_with_precision (gint              width,
                               gint              height,
                               GimpImageBaseType type,
                               GimpPrecision     precision)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpImage *image = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          G_TYPE_INT, width,
                                          G_TYPE_INT, height,
                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
                                          GIMP_TYPE_PRECISION, precision,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-new-with-precision",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    image = GIMP_VALUES_GET_IMAGE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return image;
}

/**
 * gimp_image_duplicate:
 * @image: The image.
 *
 * Duplicate the specified image
 *
 * This procedure duplicates the specified image, copying all layers,
 * channels, and image information.
 *
 * Returns: (transfer none): The new, duplicated image.
 **/
GimpImage *
gimp_image_duplicate (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpImage *new_image = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-duplicate",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    new_image = GIMP_VALUES_GET_IMAGE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return new_image;
}

/**
 * gimp_image_delete:
 * @image: The image.
 *
 * Delete the specified image.
 *
 * If there are no displays associated with this image it will be
 * deleted. This means that you can not delete an image through the PDB
 * that was created by the user. If the associated display was however
 * created through the PDB and you know the display ID, you may delete
 * the display. Removal of the last associated display will then delete
 * the image.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_delete (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-delete",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_base_type:
 * @image: The image.
 *
 * Get the base type of the image.
 *
 * This procedure returns the image's base type. Layers in the image
 * must be of this subtype, but can have an optional alpha channel.
 *
 * Returns: The image's base type.
 **/
GimpImageBaseType
gimp_image_base_type (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpImageBaseType base_type = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-base-type",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    base_type = GIMP_VALUES_GET_ENUM (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return base_type;
}

/**
 * gimp_image_get_precision:
 * @image: The image.
 *
 * Get the precision of the image.
 *
 * This procedure returns the image's precision.
 *
 * Returns: The image's precision.
 *
 * Since: 2.10
 **/
GimpPrecision
gimp_image_get_precision (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpPrecision precision = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-precision",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    precision = GIMP_VALUES_GET_ENUM (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return precision;
}

/**
 * gimp_image_get_default_new_layer_mode:
 * @image: The image.
 *
 * Get the default mode for newly created layers of this image.
 *
 * Returns the default mode for newly created layers of this image.
 *
 * Returns: The layer mode.
 *
 * Since: 2.10
 **/
GimpLayerMode
gimp_image_get_default_new_layer_mode (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayerMode mode = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-default-new-layer-mode",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    mode = GIMP_VALUES_GET_ENUM (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return mode;
}

/**
 * gimp_image_width:
 * @image: The image.
 *
 * Return the width of the image
 *
 * This procedure returns the image's width. This value is independent
 * of any of the layers in this image. This is the \"canvas\" width.
 *
 * Returns: The image's width.
 **/
gint
gimp_image_width (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gint width = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-width",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    width = GIMP_VALUES_GET_INT (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return width;
}

/**
 * gimp_image_height:
 * @image: The image.
 *
 * Return the height of the image
 *
 * This procedure returns the image's height. This value is independent
 * of any of the layers in this image. This is the \"canvas\" height.
 *
 * Returns: The image's height.
 **/
gint
gimp_image_height (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gint height = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-height",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    height = GIMP_VALUES_GET_INT (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return height;
}

/**
 * gimp_image_get_layers:
 * @image: The image.
 * @num_layers: (out): The number of layers contained in the image.
 *
 * Returns the list of layers contained in the specified image.
 *
 * This procedure returns the list of layers contained in the specified
 * image. The order of layers is from topmost to bottommost.
 *
 * Returns: (array length=num_layers) (element-type GimpLayer) (transfer container):
 *          The list of layers contained in the image.
 *          The returned value must be freed with g_free().
 **/
GimpLayer **
gimp_image_get_layers (GimpImage *image,
                       gint      *num_layers)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer **layers = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-layers",
                                              args);
  gimp_value_array_unref (args);

  *num_layers = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_layers = GIMP_VALUES_GET_INT (return_vals, 1);
      { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) layers = g_memdup (a->data, a->length * sizeof (gpointer)); };
    }

  gimp_value_array_unref (return_vals);

  return layers;
}

/**
 * gimp_image_get_channels:
 * @image: The image.
 * @num_channels: (out): The number of channels contained in the image.
 *
 * Returns the list of channels contained in the specified image.
 *
 * This procedure returns the list of channels contained in the
 * specified image. This does not include the selection mask, or layer
 * masks. The order is from topmost to bottommost. Note that
 * \"channels\" are custom channels and do not include the image's
 * color components.
 *
 * Returns: (array length=num_channels) (element-type GimpChannel) (transfer container):
 *          The list of channels contained in the image.
 *          The returned value must be freed with g_free().
 **/
GimpChannel **
gimp_image_get_channels (GimpImage *image,
                         gint      *num_channels)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpChannel **channels = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-channels",
                                              args);
  gimp_value_array_unref (args);

  *num_channels = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_channels = GIMP_VALUES_GET_INT (return_vals, 1);
      { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) channels = g_memdup (a->data, a->length * sizeof (gpointer)); };
    }

  gimp_value_array_unref (return_vals);

  return channels;
}

/**
 * gimp_image_get_vectors:
 * @image: The image.
 * @num_vectors: (out): The number of vectors contained in the image.
 *
 * Returns the list of vectors contained in the specified image.
 *
 * This procedure returns the list of vectors contained in the
 * specified image.
 *
 * Returns: (array length=num_vectors) (element-type GimpVectors) (transfer container):
 *          The list of vectors contained in the image.
 *          The returned value must be freed with g_free().
 *
 * Since: 2.4
 **/
GimpVectors **
gimp_image_get_vectors (GimpImage *image,
                        gint      *num_vectors)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpVectors **vectors = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-vectors",
                                              args);
  gimp_value_array_unref (args);

  *num_vectors = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_vectors = GIMP_VALUES_GET_INT (return_vals, 1);
      { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) vectors = g_memdup (a->data, a->length * sizeof (gpointer)); };
    }

  gimp_value_array_unref (return_vals);

  return vectors;
}

/**
 * gimp_image_get_active_drawable:
 * @image: The image.
 *
 * Get the image's active drawable
 *
 * This procedure returns the ID of the image's active drawable. This
 * can be either a layer, a channel, or a layer mask. The active
 * drawable is specified by the active image channel. If that is -1,
 * then by the active image layer. If the active image layer has a
 * layer mask and the layer mask is in edit mode, then the layer mask
 * is the active drawable.
 *
 * Returns: (transfer none): The active drawable.
 **/
GimpDrawable *
gimp_image_get_active_drawable (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpDrawable *drawable = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-active-drawable",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    drawable = GIMP_VALUES_GET_DRAWABLE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return drawable;
}

/**
 * gimp_image_unset_active_channel:
 * @image: The image.
 *
 * Unsets the active channel in the specified image.
 *
 * If an active channel exists, it is unset. There then exists no
 * active channel, and if desired, one can be set through a call to
 * 'Set Active Channel'. No error is returned in the case of no
 * existing active channel.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_unset_active_channel (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-unset-active-channel",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_floating_sel:
 * @image: The image.
 *
 * Return the floating selection of the image.
 *
 * This procedure returns the image's floating selection, if it exists.
 * If it doesn't exist, -1 is returned as the layer ID.
 *
 * Returns: (transfer none): The image's floating selection.
 **/
GimpLayer *
gimp_image_get_floating_sel (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *floating_sel = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-floating-sel",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    floating_sel = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return floating_sel;
}

/**
 * gimp_image_floating_sel_attached_to:
 * @image: The image.
 *
 * Return the drawable the floating selection is attached to.
 *
 * This procedure returns the drawable the image's floating selection
 * is attached to, if it exists. If it doesn't exist, -1 is returned as
 * the drawable ID.
 *
 * Returns: (transfer none):
 *          The drawable the floating selection is attached to.
 **/
GimpDrawable *
gimp_image_floating_sel_attached_to (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpDrawable *drawable = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-floating-sel-attached-to",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    drawable = GIMP_VALUES_GET_DRAWABLE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return drawable;
}

/**
 * gimp_image_pick_color:
 * @image: The image.
 * @drawable: (nullable): The drawable to pick from.
 * @x: x coordinate of upper-left corner of rectangle.
 * @y: y coordinate of upper-left corner of rectangle.
 * @sample_merged: Use the composite image, not the drawable.
 * @sample_average: Average the color of all the pixels in a specified radius.
 * @average_radius: The radius of pixels to average.
 * @color: (out caller-allocates): The return color.
 *
 * Determine the color at the given drawable coordinates
 *
 * This tool determines the color at the specified coordinates. The
 * returned color is an RGB triplet even for grayscale and indexed
 * drawables. If the coordinates lie outside of the extents of the
 * specified drawable, then an error is returned. If the drawable has
 * an alpha channel, the algorithm examines the alpha value of the
 * drawable at the coordinates. If the alpha value is completely
 * transparent (0), then an error is returned. If the sample_merged
 * parameter is TRUE, the data of the composite image will be used
 * instead of that for the specified drawable. This is equivalent to
 * sampling for colors after merging all visible layers. In the case of
 * a merged sampling, the supplied drawable is ignored.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_pick_color (GimpImage    *image,
                       GimpDrawable *drawable,
                       gdouble       x,
                       gdouble       y,
                       gboolean      sample_merged,
                       gboolean      sample_average,
                       gdouble       average_radius,
                       GimpRGB      *color)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_DRAWABLE, drawable,
                                          G_TYPE_DOUBLE, x,
                                          G_TYPE_DOUBLE, y,
                                          G_TYPE_BOOLEAN, sample_merged,
                                          G_TYPE_BOOLEAN, sample_average,
                                          G_TYPE_DOUBLE, average_radius,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-pick-color",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  if (success)
    GIMP_VALUES_GET_RGB (return_vals, 1, &*color);

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_pick_correlate_layer:
 * @image: The image.
 * @x: The x coordinate for the pick.
 * @y: The y coordinate for the pick.
 *
 * Find the layer visible at the specified coordinates.
 *
 * This procedure finds the layer which is visible at the specified
 * coordinates. Layers which do not qualify are those whose extents do
 * not pass within the specified coordinates, or which are transparent
 * at the specified coordinates. This procedure will return -1 if no
 * layer is found.
 *
 * Returns: (transfer none): The layer found at the specified coordinates.
 **/
GimpLayer *
gimp_image_pick_correlate_layer (GimpImage *image,
                                 gint       x,
                                 gint       y)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_INT, x,
                                          G_TYPE_INT, y,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-pick-correlate-layer",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_insert_layer:
 * @image: The image.
 * @layer: The layer.
 * @parent: (nullable): The parent layer.
 * @position: The layer position.
 *
 * Add the specified layer to the image.
 *
 * This procedure adds the specified layer to the image at the given
 * position. If the specified parent is a valid layer group (See
 * gimp_item_is_group() and gimp_layer_group_new()) then the layer is
 * added inside the group. If the parent is 0, the layer is added
 * inside the main stack, outside of any group. The position argument
 * specifies the location of the layer inside the stack (or the group,
 * if a valid parent was supplied), starting from the top (0) and
 * increasing. If the position is specified as -1 and the parent is
 * specified as 0, then the layer is inserted above the active layer,
 * or inside the group if the active layer is a layer group. The layer
 * type must be compatible with the image base type.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_insert_layer (GimpImage *image,
                         GimpLayer *layer,
                         GimpLayer *parent,
                         gint       position)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_LAYER, layer,
                                          GIMP_TYPE_LAYER, parent,
                                          G_TYPE_INT, position,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-insert-layer",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_remove_layer:
 * @image: The image.
 * @layer: The layer.
 *
 * Remove the specified layer from the image.
 *
 * This procedure removes the specified layer from the image. If the
 * layer doesn't exist, an error is returned. If there are no layers
 * left in the image, this call will fail. If this layer is the last
 * layer remaining, the image will become empty and have no active
 * layer.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_remove_layer (GimpImage *image,
                         GimpLayer *layer)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_LAYER, layer,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-remove-layer",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_freeze_layers:
 * @image: The image.
 *
 * Freeze the image's layer list.
 *
 * This procedure freezes the layer list of the image, suppressing any
 * updates to the Layers dialog in response to changes to the image's
 * layers. This can significantly improve performance while applying
 * changes affecting the layer list.
 *
 * Each call to gimp_image_freeze_layers() should be matched by a
 * corresponding call to gimp_image_thaw_layers(), undoing its effects.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_freeze_layers (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-freeze-layers",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_thaw_layers:
 * @image: The image.
 *
 * Thaw the image's layer list.
 *
 * This procedure thaws the layer list of the image, re-enabling
 * updates to the Layers dialog.
 *
 * This procedure should match a corresponding call to
 * gimp_image_freeze_layers().
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_thaw_layers (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-thaw-layers",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_insert_channel:
 * @image: The image.
 * @channel: The channel.
 * @parent: (nullable): The parent channel.
 * @position: The channel position.
 *
 * Add the specified channel to the image.
 *
 * This procedure adds the specified channel to the image at the given
 * position. Since channel groups are not currently supported, the
 * parent argument must always be 0. The position argument specifies
 * the location of the channel inside the stack, starting from the top
 * (0) and increasing. If the position is specified as -1, then the
 * channel is inserted above the active channel.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_insert_channel (GimpImage   *image,
                           GimpChannel *channel,
                           GimpChannel *parent,
                           gint         position)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL, channel,
                                          GIMP_TYPE_CHANNEL, parent,
                                          G_TYPE_INT, position,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-insert-channel",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_remove_channel:
 * @image: The image.
 * @channel: The channel.
 *
 * Remove the specified channel from the image.
 *
 * This procedure removes the specified channel from the image. If the
 * channel doesn't exist, an error is returned.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_remove_channel (GimpImage   *image,
                           GimpChannel *channel)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL, channel,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-remove-channel",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_freeze_channels:
 * @image: The image.
 *
 * Freeze the image's channel list.
 *
 * This procedure freezes the channel list of the image, suppressing
 * any updates to the Channels dialog in response to changes to the
 * image's channels. This can significantly improve performance while
 * applying changes affecting the channel list.
 *
 * Each call to gimp_image_freeze_channels() should be matched by a
 * corresponding call to gimp_image_thaw_channels(), undoing its
 * effects.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_freeze_channels (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-freeze-channels",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_thaw_channels:
 * @image: The image.
 *
 * Thaw the image's channel list.
 *
 * This procedure thaws the channel list of the image, re-enabling
 * updates to the Channels dialog.
 *
 * This procedure should match a corresponding call to
 * gimp_image_freeze_channels().
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_thaw_channels (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-thaw-channels",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_insert_vectors:
 * @image: The image.
 * @vectors: The vectors.
 * @parent: (nullable): The parent vectors.
 * @position: The vectors position.
 *
 * Add the specified vectors to the image.
 *
 * This procedure adds the specified vectors to the image at the given
 * position. Since vectors groups are not currently supported, the
 * parent argument must always be 0. The position argument specifies
 * the location of the vectors inside the stack, starting from the top
 * (0) and increasing. If the position is specified as -1, then the
 * vectors is inserted above the active vectors.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_insert_vectors (GimpImage   *image,
                           GimpVectors *vectors,
                           GimpVectors *parent,
                           gint         position)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_VECTORS, vectors,
                                          GIMP_TYPE_VECTORS, parent,
                                          G_TYPE_INT, position,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-insert-vectors",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_remove_vectors:
 * @image: The image.
 * @vectors: The vectors object.
 *
 * Remove the specified path from the image.
 *
 * This procedure removes the specified path from the image. If the
 * path doesn't exist, an error is returned.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.4
 **/
gboolean
gimp_image_remove_vectors (GimpImage   *image,
                           GimpVectors *vectors)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_VECTORS, vectors,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-remove-vectors",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_freeze_vectors:
 * @image: The image.
 *
 * Freeze the image's vectors list.
 *
 * This procedure freezes the vectors list of the image, suppressing
 * any updates to the Paths dialog in response to changes to the
 * image's vectors. This can significantly improve performance while
 * applying changes affecting the vectors list.
 *
 * Each call to gimp_image_freeze_vectors() should be matched by a
 * corresponding call to gimp_image_thaw_vectors(), undoing its
 * effects.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_freeze_vectors (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-freeze-vectors",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_thaw_vectors:
 * @image: The image.
 *
 * Thaw the image's vectors list.
 *
 * This procedure thaws the vectors list of the image, re-enabling
 * updates to the Paths dialog.
 *
 * This procedure should match a corresponding call to
 * gimp_image_freeze_vectors().
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10.2
 **/
gboolean
gimp_image_thaw_vectors (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-thaw-vectors",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_item_position:
 * @image: The image.
 * @item: The item.
 *
 * Returns the position of the item in its level of its item tree.
 *
 * This procedure determines the position of the specified item in its
 * level in its item tree in the image. If the item doesn't exist in
 * the image, or the item is not part of an item tree, an error is
 * returned.
 *
 * Returns: The position of the item in its level in the item tree.
 *
 * Since: 2.8
 **/
gint
gimp_image_get_item_position (GimpImage *image,
                              GimpItem  *item)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gint position = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-item-position",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    position = GIMP_VALUES_GET_INT (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return position;
}

/**
 * gimp_image_raise_item:
 * @image: The image.
 * @item: The item to raise.
 *
 * Raise the specified item in its level in its item tree
 *
 * This procedure raises the specified item one step in the item tree.
 * The procedure call will fail if there is no item above it.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_raise_item (GimpImage *image,
                       GimpItem  *item)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-raise-item",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_lower_item:
 * @image: The image.
 * @item: The item to lower.
 *
 * Lower the specified item in its level in its item tree
 *
 * This procedure lowers the specified item one step in the item tree.
 * The procedure call will fail if there is no item below it.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_lower_item (GimpImage *image,
                       GimpItem  *item)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-lower-item",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_raise_item_to_top:
 * @image: The image.
 * @item: The item to raise to top.
 *
 * Raise the specified item to the top of its level in its item tree
 *
 * This procedure raises the specified item to top of its level in the
 * item tree. It will not move the item if there is no item above it.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_raise_item_to_top (GimpImage *image,
                              GimpItem  *item)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-raise-item-to-top",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_lower_item_to_bottom:
 * @image: The image.
 * @item: The item to lower to bottom.
 *
 * Lower the specified item to the bottom of its level in its item tree
 *
 * This procedure lowers the specified item to bottom of its level in
 * the item tree. It will not move the layer if there is no layer below
 * it.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_lower_item_to_bottom (GimpImage *image,
                                 GimpItem  *item)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-lower-item-to-bottom",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_reorder_item:
 * @image: The image.
 * @item: The item to reorder.
 * @parent: (nullable): The new parent item.
 * @position: The new position of the item.
 *
 * Reorder the specified item within its item tree
 *
 * This procedure reorders the specified item within its item tree.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_reorder_item (GimpImage *image,
                         GimpItem  *item,
                         GimpItem  *parent,
                         gint       position)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_ITEM, item,
                                          GIMP_TYPE_ITEM, parent,
                                          G_TYPE_INT, position,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-reorder-item",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_flatten:
 * @image: The image.
 *
 * Flatten all visible layers into a single layer. Discard all
 * invisible layers.
 *
 * This procedure combines the visible layers in a manner analogous to
 * merging with the CLIP_TO_IMAGE merge type. Non-visible layers are
 * discarded, and the resulting image is stripped of its alpha channel.
 *
 * Returns: (transfer none): The resulting layer.
 **/
GimpLayer *
gimp_image_flatten (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-flatten",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_merge_visible_layers:
 * @image: The image.
 * @merge_type: The type of merge.
 *
 * Merge the visible image layers into one.
 *
 * This procedure combines the visible layers into a single layer using
 * the specified merge type. A merge type of EXPAND_AS_NECESSARY
 * expands the final layer to encompass the areas of the visible
 * layers. A merge type of CLIP_TO_IMAGE clips the final layer to the
 * extents of the image. A merge type of CLIP_TO_BOTTOM_LAYER clips the
 * final layer to the size of the bottommost layer.
 *
 * Returns: (transfer none): The resulting layer.
 **/
GimpLayer *
gimp_image_merge_visible_layers (GimpImage     *image,
                                 GimpMergeType  merge_type)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-merge-visible-layers",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_merge_down:
 * @image: The image.
 * @merge_layer: The layer to merge down from.
 * @merge_type: The type of merge.
 *
 * Merge the layer passed and the first visible layer below.
 *
 * This procedure combines the passed layer and the first visible layer
 * below it using the specified merge type. A merge type of
 * EXPAND_AS_NECESSARY expands the final layer to encompass the areas
 * of the visible layers. A merge type of CLIP_TO_IMAGE clips the final
 * layer to the extents of the image. A merge type of
 * CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the
 * bottommost layer.
 *
 * Returns: (transfer none): The resulting layer.
 **/
GimpLayer *
gimp_image_merge_down (GimpImage     *image,
                       GimpLayer     *merge_layer,
                       GimpMergeType  merge_type)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_LAYER, merge_layer,
                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-merge-down",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_merge_layer_group:
 * @image: The image.
 * @layer_group: The layer group to merge.
 *
 * Merge the passed layer group's layers into one normal layer.
 *
 * This procedure combines the layers of the passed layer group into a
 * single normal layer, replacing the group.
 *
 * Returns: (transfer none): The resulting layer.
 *
 * Since: 2.10.14
 **/
GimpLayer *
gimp_image_merge_layer_group (GimpImage *image,
                              GimpLayer *layer_group)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_LAYER, layer_group,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-merge-layer-group",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * _gimp_image_get_colormap:
 * @image: The image.
 * @num_bytes: (out): Number of bytes in the colormap array.
 *
 * Returns the image's colormap
 *
 * This procedure returns an actual pointer to the image's colormap, as
 * well as the number of bytes contained in the colormap. The actual
 * number of colors in the transmitted colormap will be 'num-bytes' /
 * 3. If the image is not in Indexed color mode, no colormap is
 * returned.
 *
 * Returns: (array length=num_bytes) (element-type guint8) (transfer full):
 *          The image's colormap.
 *          The returned value must be freed with g_free().
 **/
guint8 *
_gimp_image_get_colormap (GimpImage *image,
                          gint      *num_bytes)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  guint8 *colormap = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-colormap",
                                              args);
  gimp_value_array_unref (args);

  *num_bytes = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_bytes = GIMP_VALUES_GET_INT (return_vals, 1);
      colormap = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
    }

  gimp_value_array_unref (return_vals);

  return colormap;
}

/**
 * _gimp_image_set_colormap:
 * @image: The image.
 * @num_bytes: Number of bytes in the colormap array.
 * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
 *
 * Sets the entries in the image's colormap.
 *
 * This procedure sets the entries in the specified image's colormap.
 * The number of entries is specified by the 'num-bytes' parameter and
 * corresponds to the number of INT8 triples that must be contained in
 * the 'colormap' array. The actual number of colors in the transmitted
 * colormap is 'num-bytes' / 3.
 *
 * Returns: TRUE on success.
 **/
gboolean
_gimp_image_set_colormap (GimpImage    *image,
                          gint          num_bytes,
                          const guint8 *colormap)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_INT, num_bytes,
                                          GIMP_TYPE_UINT8_ARRAY, NULL,
                                          G_TYPE_NONE);
  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-colormap",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * _gimp_image_get_metadata:
 * @image: The image.
 *
 * Returns the image's metadata.
 *
 * Returns exif/iptc/xmp metadata from the image.
 *
 * Returns: (transfer full): The exif/ptc/xmp metadata as a string.
 *          The returned value must be freed with g_free().
 **/
gchar *
_gimp_image_get_metadata (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gchar *metadata_string = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-metadata",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    metadata_string = GIMP_VALUES_DUP_STRING (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return metadata_string;
}

/**
 * _gimp_image_set_metadata:
 * @image: The image.
 * @metadata_string: The exif/ptc/xmp metadata as a string.
 *
 * Set the image's metadata.
 *
 * Sets exif/iptc/xmp metadata on the image.
 *
 * Returns: TRUE on success.
 **/
gboolean
_gimp_image_set_metadata (GimpImage   *image,
                          const gchar *metadata_string)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, metadata_string,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-metadata",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_clean_all:
 * @image: The image.
 *
 * Set the image dirty count to 0.
 *
 * This procedure sets the specified image's dirty count to 0, allowing
 * operations to occur without having a 'dirtied' image. This is
 * especially useful for creating and loading images which should not
 * initially be considered dirty, even though layers must be created,
 * filled, and installed in the image. Note that save plug-ins must NOT
 * call this function themselves after saving the image.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_clean_all (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-clean-all",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_is_dirty:
 * @image: The image.
 *
 * Checks if the image has unsaved changes.
 *
 * This procedure checks the specified image's dirty count to see if it
 * needs to be saved. Note that saving the image does not automatically
 * set the dirty count to 0, you need to call gimp_image_clean_all()
 * after calling a save procedure to make the image clean.
 *
 * Returns: TRUE if the image has unsaved changes.
 **/
gboolean
gimp_image_is_dirty (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean dirty = FALSE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-is-dirty",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    dirty = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return dirty;
}

/**
 * _gimp_image_thumbnail:
 * @image: The image.
 * @width: The requested thumbnail width.
 * @height: The requested thumbnail height.
 * @actual_width: (out): The previews width.
 * @actual_height: (out): The previews height.
 * @bpp: (out): The previews bpp.
 * @thumbnail_data_count: (out): The number of bytes in thumbnail data.
 * @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The thumbnail data.
 *
 * Get a thumbnail of an image.
 *
 * This function gets data from which a thumbnail of an image preview
 * can be created. Maximum x or y dimension is 1024 pixels. The pixels
 * are returned in RGB[A] or GRAY[A] format. The bpp return value gives
 * the number of bits per pixel in the image.
 *
 * Returns: TRUE on success.
 **/
gboolean
_gimp_image_thumbnail (GimpImage  *image,
                       gint        width,
                       gint        height,
                       gint       *actual_width,
                       gint       *actual_height,
                       gint       *bpp,
                       gint       *thumbnail_data_count,
                       guint8    **thumbnail_data)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_INT, width,
                                          G_TYPE_INT, height,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-thumbnail",
                                              args);
  gimp_value_array_unref (args);

  *actual_width = 0;
  *actual_height = 0;
  *bpp = 0;
  *thumbnail_data_count = 0;
  *thumbnail_data = NULL;

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  if (success)
    {
      *actual_width = GIMP_VALUES_GET_INT (return_vals, 1);
      *actual_height = GIMP_VALUES_GET_INT (return_vals, 2);
      *bpp = GIMP_VALUES_GET_INT (return_vals, 3);
      *thumbnail_data_count = GIMP_VALUES_GET_INT (return_vals, 4);
      *thumbnail_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
    }

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_active_layer:
 * @image: The image.
 *
 * Returns the specified image's active layer.
 *
 * If there is an active layer, its ID will be returned, otherwise, -1.
 * If a channel is currently active, then no layer will be. If a layer
 * mask is active, then this will return the associated layer.
 *
 * Returns: (transfer none): The active layer.
 **/
GimpLayer *
gimp_image_get_active_layer (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *active_layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-active-layer",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    active_layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return active_layer;
}

/**
 * gimp_image_set_active_layer:
 * @image: The image.
 * @active_layer: The new image active layer.
 *
 * Sets the specified image's active layer.
 *
 * If the layer exists, it is set as the active layer in the image. Any
 * previous active layer or channel is set to inactive. An exception is
 * a previously existing floating selection, in which case this
 * procedure will return an execution error.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_active_layer (GimpImage *image,
                             GimpLayer *active_layer)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_LAYER, active_layer,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-active-layer",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_active_channel:
 * @image: The image.
 *
 * Returns the specified image's active channel.
 *
 * If there is an active channel, this will return the channel ID,
 * otherwise, -1.
 *
 * Returns: (transfer none): The active channel.
 **/
GimpChannel *
gimp_image_get_active_channel (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpChannel *active_channel = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-active-channel",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    active_channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return active_channel;
}

/**
 * gimp_image_set_active_channel:
 * @image: The image.
 * @active_channel: The new image active channel.
 *
 * Sets the specified image's active channel.
 *
 * If the channel exists, it is set as the active channel in the image.
 * Any previous active channel or layer is set to inactive. An
 * exception is a previously existing floating selection, in which case
 * this procedure will return an execution error.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_active_channel (GimpImage   *image,
                               GimpChannel *active_channel)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL, active_channel,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-active-channel",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_active_vectors:
 * @image: The image.
 *
 * Returns the specified image's active vectors.
 *
 * If there is an active path, its ID will be returned, otherwise, -1.
 *
 * Returns: (transfer none): The active vectors.
 **/
GimpVectors *
gimp_image_get_active_vectors (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpVectors *active_vectors = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-active-vectors",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    active_vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return active_vectors;
}

/**
 * gimp_image_set_active_vectors:
 * @image: The image.
 * @active_vectors: The new image active vectors.
 *
 * Sets the specified image's active vectors.
 *
 * If the path exists, it is set as the active path in the image.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_active_vectors (GimpImage   *image,
                               GimpVectors *active_vectors)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_VECTORS, active_vectors,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-active-vectors",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_selection:
 * @image: The image.
 *
 * Returns the specified image's selection.
 *
 * This will always return a valid ID for a selection -- which is
 * represented as a channel internally.
 *
 * Returns: (transfer none): The selection channel.
 **/
GimpSelection *
gimp_image_get_selection (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpSelection *selection = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-selection",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    selection = GIMP_VALUES_GET_SELECTION (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return selection;
}

/**
 * gimp_image_get_component_active:
 * @image: The image.
 * @component: The image component.
 *
 * Returns if the specified image's image component is active.
 *
 * This procedure returns if the specified image's image component
 * (i.e. Red, Green, Blue intensity channels in an RGB image) is active
 * or inactive -- whether or not it can be modified. If the specified
 * component is not valid for the image type, an error is returned.
 *
 * Returns: Component is active.
 **/
gboolean
gimp_image_get_component_active (GimpImage       *image,
                                 GimpChannelType  component)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean active = FALSE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-component-active",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    active = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return active;
}

/**
 * gimp_image_set_component_active:
 * @image: The image.
 * @component: The image component.
 * @active: Component is active.
 *
 * Sets if the specified image's image component is active.
 *
 * This procedure sets if the specified image's image component (i.e.
 * Red, Green, Blue intensity channels in an RGB image) is active or
 * inactive -- whether or not it can be modified. If the specified
 * component is not valid for the image type, an error is returned.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_component_active (GimpImage       *image,
                                 GimpChannelType  component,
                                 gboolean         active)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                          G_TYPE_BOOLEAN, active,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-component-active",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_component_visible:
 * @image: The image.
 * @component: The image component.
 *
 * Returns if the specified image's image component is visible.
 *
 * This procedure returns if the specified image's image component
 * (i.e. Red, Green, Blue intensity channels in an RGB image) is
 * visible or invisible -- whether or not it can be seen. If the
 * specified component is not valid for the image type, an error is
 * returned.
 *
 * Returns: Component is visible.
 **/
gboolean
gimp_image_get_component_visible (GimpImage       *image,
                                  GimpChannelType  component)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean visible = FALSE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-component-visible",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    visible = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return visible;
}

/**
 * gimp_image_set_component_visible:
 * @image: The image.
 * @component: The image component.
 * @visible: Component is visible.
 *
 * Sets if the specified image's image component is visible.
 *
 * This procedure sets if the specified image's image component (i.e.
 * Red, Green, Blue intensity channels in an RGB image) is visible or
 * invisible -- whether or not it can be seen. If the specified
 * component is not valid for the image type, an error is returned.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_component_visible (GimpImage       *image,
                                  GimpChannelType  component,
                                  gboolean         visible)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                          G_TYPE_BOOLEAN, visible,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-component-visible",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_file:
 * @image: The image.
 *
 * Returns the file for the specified image.
 *
 * This procedure returns the file associated with the specified image.
 * The image has a file only if it was loaded or imported from a file
 * or has since been saved or exported. Otherwise, this function
 * returns %NULL. See also gimp-image-get-imported-file to get the
 * current file if it was imported from a non-GIMP file format and not
 * yet saved, or gimp-image-get-exported-file if the image has been
 * exported to a non-GIMP file format.
 *
 * Returns: (transfer full): The file.
 *
 * Since: 2.8
 **/
GFile *
gimp_image_get_file (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GFile *file = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-file",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    file = GIMP_VALUES_DUP_FILE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return file;
}

/**
 * gimp_image_set_file:
 * @image: The image.
 * @file: The new image file.
 *
 * Sets the specified image's file.
 *
 * This procedure sets the specified image's file.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_file (GimpImage *image,
                     GFile     *file)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_FILE, file,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-file",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_xcf_file:
 * @image: The image.
 *
 * Returns the XCF file for the specified image.
 *
 * This procedure returns the XCF file associated with the image. If
 * there is no such file, this procedure returns %NULL.
 *
 * Returns: (transfer full): The imported XCF file.
 *
 * Since: 2.8
 **/
GFile *
gimp_image_get_xcf_file (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GFile *file = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-xcf-file",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    file = GIMP_VALUES_DUP_FILE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return file;
}

/**
 * gimp_image_get_imported_file:
 * @image: The image.
 *
 * Returns the imported file for the specified image.
 *
 * This procedure returns the file associated with the specified image
 * if the image was imported from a non-native Gimp format. If the
 * image was not imported, or has since been saved in the native Gimp
 * format, this procedure returns %NULL.
 *
 * Returns: (transfer full): The imported file.
 *
 * Since: 2.8
 **/
GFile *
gimp_image_get_imported_file (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GFile *file = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-imported-file",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    file = GIMP_VALUES_DUP_FILE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return file;
}

/**
 * gimp_image_get_exported_file:
 * @image: The image.
 *
 * Returns the exported file for the specified image.
 *
 * This procedure returns the file associated with the specified image
 * if the image was exported a non-native GIMP format. If the image was
 * not exported, this procedure returns %NULL.
 *
 * Returns: (transfer full): The exported file.
 *
 * Since: 2.8
 **/
GFile *
gimp_image_get_exported_file (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GFile *file = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-exported-file",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    file = GIMP_VALUES_DUP_FILE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return file;
}

/**
 * gimp_image_get_name:
 * @image: The image.
 *
 * Returns the specified image's name.
 *
 * This procedure returns the image's name. If the image has a filename
 * or an URI, then the returned name contains the filename's or URI's
 * base name (the last component of the path). Otherwise it is the
 * translated string \"Untitled\". The returned name is formatted like
 * the image name in the image window title, it may contain '[]',
 * '(imported)' etc. and should only be used to label user interface
 * elements. Never use it to construct filenames.
 *
 * Returns: (transfer full): The name.
 *          The returned value must be freed with g_free().
 **/
gchar *
gimp_image_get_name (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gchar *name = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-name",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    name = GIMP_VALUES_DUP_STRING (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return name;
}

/**
 * gimp_image_get_resolution:
 * @image: The image.
 * @xresolution: (out): The resolution in the x-axis, in dots per inch.
 * @yresolution: (out): The resolution in the y-axis, in dots per inch.
 *
 * Returns the specified image's resolution.
 *
 * This procedure returns the specified image's resolution in dots per
 * inch. This value is independent of any of the layers in this image.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_get_resolution (GimpImage *image,
                           gdouble   *xresolution,
                           gdouble   *yresolution)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-resolution",
                                              args);
  gimp_value_array_unref (args);

  *xresolution = 0.0;
  *yresolution = 0.0;

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  if (success)
    {
      *xresolution = GIMP_VALUES_GET_DOUBLE (return_vals, 1);
      *yresolution = GIMP_VALUES_GET_DOUBLE (return_vals, 2);
    }

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_set_resolution:
 * @image: The image.
 * @xresolution: The new image resolution in the x-axis, in dots per inch.
 * @yresolution: The new image resolution in the y-axis, in dots per inch.
 *
 * Sets the specified image's resolution.
 *
 * This procedure sets the specified image's resolution in dots per
 * inch. This value is independent of any of the layers in this image.
 * No scaling or resizing is performed.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_resolution (GimpImage *image,
                           gdouble    xresolution,
                           gdouble    yresolution)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_DOUBLE, xresolution,
                                          G_TYPE_DOUBLE, yresolution,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-resolution",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_unit:
 * @image: The image.
 *
 * Returns the specified image's unit.
 *
 * This procedure returns the specified image's unit. This value is
 * independent of any of the layers in this image. See the
 * gimp_unit_*() procedure definitions for the valid range of unit IDs
 * and a description of the unit system.
 *
 * Returns: (transfer none): The unit.
 **/
GimpUnit
gimp_image_get_unit (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpUnit unit = GIMP_UNIT_PIXEL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-unit",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    unit = GIMP_VALUES_GET_INT (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return unit;
}

/**
 * gimp_image_set_unit:
 * @image: The image.
 * @unit: The new image unit.
 *
 * Sets the specified image's unit.
 *
 * This procedure sets the specified image's unit. No scaling or
 * resizing is performed. This value is independent of any of the
 * layers in this image. See the gimp_unit_*() procedure definitions
 * for the valid range of unit IDs and a description of the unit
 * system.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_unit (GimpImage *image,
                     GimpUnit   unit)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_UNIT, unit,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-unit",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_tattoo_state:
 * @image: The image.
 *
 * Returns the tattoo state associated with the image.
 *
 * This procedure returns the tattoo state of the image. Use only by
 * save/load plug-ins that wish to preserve an images tattoo state.
 * Using this function at other times will produce unexpected results.
 *
 * Returns: The tattoo state.
 **/
guint
gimp_image_get_tattoo_state (GimpImage *image)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  guint tattoo_state = 0;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-tattoo-state",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    tattoo_state = GIMP_VALUES_GET_UINT (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return tattoo_state;
}

/**
 * gimp_image_set_tattoo_state:
 * @image: The image.
 * @tattoo_state: The new image tattoo state.
 *
 * Set the tattoo state associated with the image.
 *
 * This procedure sets the tattoo state of the image. Use only by
 * save/load plug-ins that wish to preserve an images tattoo state.
 * Using this function at other times will produce unexpected results.
 * A full check of uniqueness of states in layers, channels and paths
 * will be performed by this procedure and a execution failure will be
 * returned if this fails. A failure will also be returned if the new
 * tattoo state value is less than the maximum tattoo value from all of
 * the tattoos from the paths, layers and channels. After the image
 * data has been loaded and all the tattoos have been set then this is
 * the last procedure that should be called. If effectively does a
 * status check on the tattoo values that have been set to make sure
 * that all is OK.
 *
 * Returns: TRUE on success.
 **/
gboolean
gimp_image_set_tattoo_state (GimpImage *image,
                             guint      tattoo_state)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_UINT, tattoo_state,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-set-tattoo-state",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_layer_by_tattoo:
 * @image: The image.
 * @tattoo: The tattoo of the layer to find.
 *
 * Find a layer with a given tattoo in an image.
 *
 * This procedure returns the layer with the given tattoo in the
 * specified image.
 *
 * Returns: (transfer none): The layer with the specified tattoo.
 **/
GimpLayer *
gimp_image_get_layer_by_tattoo (GimpImage *image,
                                guint      tattoo)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_UINT, tattoo,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-layer-by-tattoo",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_get_channel_by_tattoo:
 * @image: The image.
 * @tattoo: The tattoo of the channel to find.
 *
 * Find a channel with a given tattoo in an image.
 *
 * This procedure returns the channel with the given tattoo in the
 * specified image.
 *
 * Returns: (transfer none): The channel with the specified tattoo.
 **/
GimpChannel *
gimp_image_get_channel_by_tattoo (GimpImage *image,
                                  guint      tattoo)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpChannel *channel = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_UINT, tattoo,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-channel-by-tattoo",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return channel;
}

/**
 * gimp_image_get_vectors_by_tattoo:
 * @image: The image.
 * @tattoo: The tattoo of the vectors to find.
 *
 * Find a vectors with a given tattoo in an image.
 *
 * This procedure returns the vectors with the given tattoo in the
 * specified image.
 *
 * Returns: (transfer none): The vectors with the specified tattoo.
 *
 * Since: 2.6
 **/
GimpVectors *
gimp_image_get_vectors_by_tattoo (GimpImage *image,
                                  guint      tattoo)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpVectors *vectors = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_UINT, tattoo,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-vectors-by-tattoo",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return vectors;
}

/**
 * gimp_image_get_layer_by_name:
 * @image: The image.
 * @name: The name of the layer to find.
 *
 * Find a layer with a given name in an image.
 *
 * This procedure returns the layer with the given name in the
 * specified image.
 *
 * Returns: (transfer none): The layer with the specified name.
 *
 * Since: 2.8
 **/
GimpLayer *
gimp_image_get_layer_by_name (GimpImage   *image,
                              const gchar *name)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpLayer *layer = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, name,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-layer-by-name",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    layer = GIMP_VALUES_GET_LAYER (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return layer;
}

/**
 * gimp_image_get_channel_by_name:
 * @image: The image.
 * @name: The name of the channel to find.
 *
 * Find a channel with a given name in an image.
 *
 * This procedure returns the channel with the given name in the
 * specified image.
 *
 * Returns: (transfer none): The channel with the specified name.
 *
 * Since: 2.8
 **/
GimpChannel *
gimp_image_get_channel_by_name (GimpImage   *image,
                                const gchar *name)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpChannel *channel = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, name,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-channel-by-name",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return channel;
}

/**
 * gimp_image_get_vectors_by_name:
 * @image: The image.
 * @name: The name of the vectors to find.
 *
 * Find a vectors with a given name in an image.
 *
 * This procedure returns the vectors with the given name in the
 * specified image.
 *
 * Returns: (transfer none): The vectors with the specified name.
 *
 * Since: 2.8
 **/
GimpVectors *
gimp_image_get_vectors_by_name (GimpImage   *image,
                                const gchar *name)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpVectors *vectors = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, name,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-vectors-by-name",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return vectors;
}

/**
 * gimp_image_attach_parasite:
 * @image: The image.
 * @parasite: The parasite to attach to an image.
 *
 * Add a parasite to an image.
 *
 * This procedure attaches a parasite to an image. It has no return
 * values.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_attach_parasite (GimpImage          *image,
                            const GimpParasite *parasite)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          GIMP_TYPE_PARASITE, parasite,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-attach-parasite",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_detach_parasite:
 * @image: The image.
 * @name: The name of the parasite to detach from an image.
 *
 * Removes a parasite from an image.
 *
 * This procedure detaches a parasite from an image. It has no return
 * values.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.8
 **/
gboolean
gimp_image_detach_parasite (GimpImage   *image,
                            const gchar *name)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gboolean success = TRUE;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, name,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-detach-parasite",
                                              args);
  gimp_value_array_unref (args);

  success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;

  gimp_value_array_unref (return_vals);

  return success;
}

/**
 * gimp_image_get_parasite:
 * @image: The image.
 * @name: The name of the parasite to find.
 *
 * Look up a parasite in an image
 *
 * Finds and returns the parasite that was previously attached to an
 * image.
 *
 * Returns: (transfer full): The found parasite.
 *
 * Since: 2.8
 **/
GimpParasite *
gimp_image_get_parasite (GimpImage   *image,
                         const gchar *name)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  GimpParasite *parasite = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_STRING, name,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-parasite",
                                              args);
  gimp_value_array_unref (args);

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    parasite = GIMP_VALUES_DUP_PARASITE (return_vals, 1);

  gimp_value_array_unref (return_vals);

  return parasite;
}

/**
 * gimp_image_get_parasite_list:
 * @image: The image.
 * @num_parasites: (out): The number of attached parasites.
 *
 * List all parasites.
 *
 * Returns a list of all currently attached parasites.
 *
 * Returns: (array length=num_parasites) (element-type gchar*) (transfer full):
 *          The names of currently attached parasites.
 *          The returned value must be freed with g_strfreev().
 *
 * Since: 2.8
 **/
gchar **
gimp_image_get_parasite_list (GimpImage *image,
                              gint      *num_parasites)
{
  GimpValueArray *args;
  GimpValueArray *return_vals;
  gchar **parasites = NULL;

  args = gimp_value_array_new_from_types (NULL,
                                          GIMP_TYPE_IMAGE, image,
                                          G_TYPE_NONE);

  return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
                                              "gimp-image-get-parasite-list",
                                              args);
  gimp_value_array_unref (args);

  *num_parasites = 0;

  if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
    {
      *num_parasites = GIMP_VALUES_GET_INT (return_vals, 1);
      parasites = GIMP_VALUES_DUP_STRING_ARRAY (return_vals, 2);
    }

  gimp_value_array_unref (return_vals);

  return parasites;
}