Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3223 insertions, 0 deletions

diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
new file mode 100644
index 0000000..b38a152
--- /dev/null
+++ b/libgimp/gimpimage_pdb.c
@@ -0,0 +1,3223 @@
+/* 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 <string.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_is_valid:
+ * @image_ID: The image to check.
+ *
+ * Returns TRUE if the image 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: 2.4
+ **/
+gboolean
+gimp_image_is_valid (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean valid = FALSE;
+
+  return_vals = gimp_run_procedure ("gimp-image-is-valid",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    valid = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return valid;
+}
+
+/**
+ * gimp_image_list:
+ * @num_images: 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: The list of images currently open. The returned value must
+ * be freed with g_free().
+ **/
+gint *
+gimp_image_list (gint *num_images)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint *image_ids = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-list",
+                                    &nreturn_vals,
+                                    GIMP_PDB_END);
+
+  *num_images = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_images = return_vals[1].data.d_int32;
+      image_ids = g_new (gint32, *num_images);
+      memcpy (image_ids,
+              return_vals[2].data.d_int32array,
+              *num_images * sizeof (gint32));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return image_ids;
+}
+
+/**
+ * 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: The ID of the newly created image.
+ **/
+gint32
+gimp_image_new (gint              width,
+                gint              height,
+                GimpImageBaseType type)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 image_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-new",
+                                    &nreturn_vals,
+                                    GIMP_PDB_INT32, width,
+                                    GIMP_PDB_INT32, height,
+                                    GIMP_PDB_INT32, type,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    image_ID = return_vals[1].data.d_image;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return image_ID;
+}
+
+/**
+ * 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_GAMMA precision. See gimp_image_new() for further
+ * details.
+ *
+ * Returns: The ID of the newly created image.
+ *
+ * Since: 2.10
+ **/
+gint32
+gimp_image_new_with_precision (gint              width,
+                               gint              height,
+                               GimpImageBaseType type,
+                               GimpPrecision     precision)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 image_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-new-with-precision",
+                                    &nreturn_vals,
+                                    GIMP_PDB_INT32, width,
+                                    GIMP_PDB_INT32, height,
+                                    GIMP_PDB_INT32, type,
+                                    GIMP_PDB_INT32, precision,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    image_ID = return_vals[1].data.d_image;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return image_ID;
+}
+
+/**
+ * gimp_image_duplicate:
+ * @image_ID: The image.
+ *
+ * Duplicate the specified image
+ *
+ * This procedure duplicates the specified image, copying all layers,
+ * channels, and image information.
+ *
+ * Returns: The new, duplicated image.
+ **/
+gint32
+gimp_image_duplicate (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 new_image_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-duplicate",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    new_image_ID = return_vals[1].data.d_image;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return new_image_ID;
+}
+
+/**
+ * gimp_image_delete:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-delete",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_base_type:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  GimpImageBaseType base_type = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-base-type",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    base_type = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return base_type;
+}
+
+/**
+ * gimp_image_get_precision:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  GimpPrecision precision = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-precision",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    precision = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return precision;
+}
+
+/**
+ * gimp_image_get_default_new_layer_mode:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  GimpLayerMode mode = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-default-new-layer-mode",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    mode = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return mode;
+}
+
+/**
+ * gimp_image_width:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint width = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-width",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    width = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return width;
+}
+
+/**
+ * gimp_image_height:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint height = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-height",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    height = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return height;
+}
+
+/**
+ * gimp_image_free_shadow:
+ * @image_ID: The image.
+ *
+ * Deprecated: Use gimp_drawable_free_shadow() instead.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_free_shadow (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-free-shadow",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_layers:
+ * @image_ID: The image.
+ * @num_layers: 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: The list of layers contained in the image. The returned
+ * value must be freed with g_free().
+ **/
+gint *
+gimp_image_get_layers (gint32  image_ID,
+                       gint   *num_layers)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint *layer_ids = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-layers",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *num_layers = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_layers = return_vals[1].data.d_int32;
+      layer_ids = g_new (gint32, *num_layers);
+      memcpy (layer_ids,
+              return_vals[2].data.d_int32array,
+              *num_layers * sizeof (gint32));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ids;
+}
+
+/**
+ * gimp_image_get_channels:
+ * @image_ID: The image.
+ * @num_channels: 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: The list of channels contained in the image. The returned
+ * value must be freed with g_free().
+ **/
+gint *
+gimp_image_get_channels (gint32  image_ID,
+                         gint   *num_channels)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint *channel_ids = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-channels",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *num_channels = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_channels = return_vals[1].data.d_int32;
+      channel_ids = g_new (gint32, *num_channels);
+      memcpy (channel_ids,
+              return_vals[2].data.d_int32array,
+              *num_channels * sizeof (gint32));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return channel_ids;
+}
+
+/**
+ * gimp_image_get_vectors:
+ * @image_ID: The image.
+ * @num_vectors: 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: The list of vectors contained in the image. The returned
+ * value must be freed with g_free().
+ *
+ * Since: 2.4
+ **/
+gint *
+gimp_image_get_vectors (gint32  image_ID,
+                        gint   *num_vectors)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint *vector_ids = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *num_vectors = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_vectors = return_vals[1].data.d_int32;
+      vector_ids = g_new (gint32, *num_vectors);
+      memcpy (vector_ids,
+              return_vals[2].data.d_int32array,
+              *num_vectors * sizeof (gint32));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return vector_ids;
+}
+
+/**
+ * gimp_image_get_active_drawable:
+ * @image_ID: 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: The active drawable.
+ **/
+gint32
+gimp_image_get_active_drawable (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 drawable_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-active-drawable",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    drawable_ID = return_vals[1].data.d_drawable;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return drawable_ID;
+}
+
+/**
+ * gimp_image_unset_active_channel:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-unset-active-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_floating_sel:
+ * @image_ID: 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: The image's floating selection.
+ **/
+gint32
+gimp_image_get_floating_sel (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 floating_sel_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-floating-sel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    floating_sel_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return floating_sel_ID;
+}
+
+/**
+ * gimp_image_floating_sel_attached_to:
+ * @image_ID: 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: The drawable the floating selection is attached to.
+ **/
+gint32
+gimp_image_floating_sel_attached_to (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 drawable_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-floating-sel-attached-to",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    drawable_ID = return_vals[1].data.d_drawable;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return drawable_ID;
+}
+
+/**
+ * gimp_image_pick_color:
+ * @image_ID: The image.
+ * @drawable_ID: 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: 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 (gint32    image_ID,
+                       gint32    drawable_ID,
+                       gdouble   x,
+                       gdouble   y,
+                       gboolean  sample_merged,
+                       gboolean  sample_average,
+                       gdouble   average_radius,
+                       GimpRGB  *color)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-pick-color",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_DRAWABLE, drawable_ID,
+                                    GIMP_PDB_FLOAT, x,
+                                    GIMP_PDB_FLOAT, y,
+                                    GIMP_PDB_INT32, sample_merged,
+                                    GIMP_PDB_INT32, sample_average,
+                                    GIMP_PDB_FLOAT, average_radius,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  if (success)
+    *color = return_vals[1].data.d_color;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_pick_correlate_layer:
+ * @image_ID: 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: The layer found at the specified coordinates.
+ **/
+gint32
+gimp_image_pick_correlate_layer (gint32 image_ID,
+                                 gint   x,
+                                 gint   y)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-pick-correlate-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, x,
+                                    GIMP_PDB_INT32, y,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_add_layer:
+ * @image_ID: The image.
+ * @layer_ID: The layer.
+ * @position: The layer position.
+ *
+ * Deprecated: Use gimp_image_insert_layer() instead.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_add_layer (gint32 image_ID,
+                      gint32 layer_ID,
+                      gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-add-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, layer_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_insert_layer:
+ * @image_ID: The image.
+ * @layer_ID: The layer.
+ * @parent_ID: 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 (gint32 image_ID,
+                         gint32 layer_ID,
+                         gint32 parent_ID,
+                         gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-insert-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, layer_ID,
+                                    GIMP_PDB_LAYER, parent_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_remove_layer:
+ * @image_ID: The image.
+ * @layer_ID: 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 (gint32 image_ID,
+                         gint32 layer_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-remove-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, layer_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_freeze_layers:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-freeze-layers",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_thaw_layers:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-thaw-layers",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_add_channel:
+ * @image_ID: The image.
+ * @channel_ID: The channel.
+ * @position: The channel position.
+ *
+ * Deprecated: Use gimp_image_insert_channel() instead.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_add_channel (gint32 image_ID,
+                        gint32 channel_ID,
+                        gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-add-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_CHANNEL, channel_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_insert_channel:
+ * @image_ID: The image.
+ * @channel_ID: The channel.
+ * @parent_ID: 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 (gint32 image_ID,
+                           gint32 channel_ID,
+                           gint32 parent_ID,
+                           gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-insert-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_CHANNEL, channel_ID,
+                                    GIMP_PDB_CHANNEL, parent_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_remove_channel:
+ * @image_ID: The image.
+ * @channel_ID: 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 (gint32 image_ID,
+                           gint32 channel_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-remove-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_CHANNEL, channel_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_freeze_channels:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-freeze-channels",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_thaw_channels:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-thaw-channels",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_add_vectors:
+ * @image_ID: The image.
+ * @vectors_ID: The vectors object.
+ * @position: The vectors objects position.
+ *
+ * Deprecated: Use gimp_image_insert_vectors() instead.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_add_vectors (gint32 image_ID,
+                        gint32 vectors_ID,
+                        gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-add-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_VECTORS, vectors_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_insert_vectors:
+ * @image_ID: The image.
+ * @vectors_ID: The vectors.
+ * @parent_ID: 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 (gint32 image_ID,
+                           gint32 vectors_ID,
+                           gint32 parent_ID,
+                           gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-insert-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_VECTORS, vectors_ID,
+                                    GIMP_PDB_VECTORS, parent_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_remove_vectors:
+ * @image_ID: The image.
+ * @vectors_ID: 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 (gint32 image_ID,
+                           gint32 vectors_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-remove-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_VECTORS, vectors_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_freeze_vectors:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-freeze-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_thaw_vectors:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-thaw-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_item_position:
+ * @image_ID: The image.
+ * @item_ID: 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 (gint32 image_ID,
+                              gint32 item_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint position = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-item-position",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    position = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return position;
+}
+
+/**
+ * gimp_image_raise_item:
+ * @image_ID: The image.
+ * @item_ID: 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 (gint32 image_ID,
+                       gint32 item_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-raise-item",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_lower_item:
+ * @image_ID: The image.
+ * @item_ID: 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 (gint32 image_ID,
+                       gint32 item_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-lower-item",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_raise_item_to_top:
+ * @image_ID: The image.
+ * @item_ID: 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 (gint32 image_ID,
+                              gint32 item_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-raise-item-to-top",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_lower_item_to_bottom:
+ * @image_ID: The image.
+ * @item_ID: 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 (gint32 image_ID,
+                                 gint32 item_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-lower-item-to-bottom",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_reorder_item:
+ * @image_ID: The image.
+ * @item_ID: The item to reorder.
+ * @parent_ID: 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 (gint32 image_ID,
+                         gint32 item_ID,
+                         gint32 parent_ID,
+                         gint   position)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-reorder-item",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_ITEM, item_ID,
+                                    GIMP_PDB_ITEM, parent_ID,
+                                    GIMP_PDB_INT32, position,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_flatten:
+ * @image_ID: 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: The resulting layer.
+ **/
+gint32
+gimp_image_flatten (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-flatten",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_merge_visible_layers:
+ * @image_ID: 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: The resulting layer.
+ **/
+gint32
+gimp_image_merge_visible_layers (gint32        image_ID,
+                                 GimpMergeType merge_type)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-merge-visible-layers",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, merge_type,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_merge_down:
+ * @image_ID: The image.
+ * @merge_layer_ID: 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: The resulting layer.
+ **/
+gint32
+gimp_image_merge_down (gint32        image_ID,
+                       gint32        merge_layer_ID,
+                       GimpMergeType merge_type)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-merge-down",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, merge_layer_ID,
+                                    GIMP_PDB_INT32, merge_type,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_merge_layer_group:
+ * @image_ID: The image.
+ * @layer_group_ID: 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: The resulting layer.
+ *
+ * Since: 2.10.14
+ **/
+gint32
+gimp_image_merge_layer_group (gint32 image_ID,
+                              gint32 layer_group_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-merge-layer-group",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, layer_group_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * _gimp_image_get_colormap:
+ * @image_ID: The image.
+ * @num_bytes: 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: The image's colormap. The returned value must be freed with
+ * g_free().
+ **/
+guint8 *
+_gimp_image_get_colormap (gint32  image_ID,
+                          gint   *num_bytes)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  guint8 *colormap = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-colormap",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *num_bytes = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_bytes = return_vals[1].data.d_int32;
+      colormap = g_new (guint8, *num_bytes);
+      memcpy (colormap,
+              return_vals[2].data.d_int8array,
+              *num_bytes * sizeof (guint8));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return colormap;
+}
+
+/**
+ * _gimp_image_set_colormap:
+ * @image_ID: The image.
+ * @num_bytes: Number of bytes in the colormap array.
+ * @colormap: 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 (gint32        image_ID,
+                          gint          num_bytes,
+                          const guint8 *colormap)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-colormap",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, num_bytes,
+                                    GIMP_PDB_INT8ARRAY, colormap,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_get_metadata:
+ * @image_ID: The image.
+ *
+ * Returns the image's metadata.
+ *
+ * Returns exif/iptc/xmp metadata from the image.
+ *
+ * Returns: The exif/ptc/xmp metadata as a string.
+ **/
+gchar *
+_gimp_image_get_metadata (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *metadata_string = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-metadata",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    metadata_string = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return metadata_string;
+}
+
+/**
+ * _gimp_image_set_metadata:
+ * @image_ID: 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 (gint32       image_ID,
+                          const gchar *metadata_string)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-metadata",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, metadata_string,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_clean_all:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-clean-all",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_is_dirty:
+ * @image_ID: 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 (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean dirty = FALSE;
+
+  return_vals = gimp_run_procedure ("gimp-image-is-dirty",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    dirty = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return dirty;
+}
+
+/**
+ * _gimp_image_thumbnail:
+ * @image_ID: The image.
+ * @width: The requested thumbnail width.
+ * @height: The requested thumbnail height.
+ * @actual_width: The previews width.
+ * @actual_height: The previews height.
+ * @bpp: The previews bpp.
+ * @thumbnail_data_count: The number of bytes in thumbnail data.
+ * @thumbnail_data: 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 (gint32   image_ID,
+                       gint     width,
+                       gint     height,
+                       gint    *actual_width,
+                       gint    *actual_height,
+                       gint    *bpp,
+                       gint    *thumbnail_data_count,
+                       guint8 **thumbnail_data)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-thumbnail",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, width,
+                                    GIMP_PDB_INT32, height,
+                                    GIMP_PDB_END);
+
+  *actual_width = 0;
+  *actual_height = 0;
+  *bpp = 0;
+  *thumbnail_data_count = 0;
+  *thumbnail_data = NULL;
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *actual_width = return_vals[1].data.d_int32;
+      *actual_height = return_vals[2].data.d_int32;
+      *bpp = return_vals[3].data.d_int32;
+      *thumbnail_data_count = return_vals[4].data.d_int32;
+      *thumbnail_data = g_new (guint8, *thumbnail_data_count);
+      memcpy (*thumbnail_data,
+              return_vals[5].data.d_int8array,
+              *thumbnail_data_count * sizeof (guint8));
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_layer:
+ * @image_ID: 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: The active layer.
+ **/
+gint32
+gimp_image_get_active_layer (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 active_layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-active-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    active_layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return active_layer_ID;
+}
+
+/**
+ * gimp_image_set_active_layer:
+ * @image_ID: The image.
+ * @active_layer_ID: 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 (gint32 image_ID,
+                             gint32 active_layer_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-active-layer",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_LAYER, active_layer_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_channel:
+ * @image_ID: The image.
+ *
+ * Returns the specified image's active channel.
+ *
+ * If there is an active channel, this will return the channel ID,
+ * otherwise, -1.
+ *
+ * Returns: The active channel.
+ **/
+gint32
+gimp_image_get_active_channel (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 active_channel_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-active-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    active_channel_ID = return_vals[1].data.d_channel;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return active_channel_ID;
+}
+
+/**
+ * gimp_image_set_active_channel:
+ * @image_ID: The image.
+ * @active_channel_ID: 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 (gint32 image_ID,
+                               gint32 active_channel_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-active-channel",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_CHANNEL, active_channel_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_vectors:
+ * @image_ID: The image.
+ *
+ * Returns the specified image's active vectors.
+ *
+ * If there is an active path, its ID will be returned, otherwise, -1.
+ *
+ * Returns: The active vectors.
+ **/
+gint32
+gimp_image_get_active_vectors (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 active_vectors_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-active-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    active_vectors_ID = return_vals[1].data.d_vectors;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return active_vectors_ID;
+}
+
+/**
+ * gimp_image_set_active_vectors:
+ * @image_ID: The image.
+ * @active_vectors_ID: 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 (gint32 image_ID,
+                               gint32 active_vectors_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-active-vectors",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_VECTORS, active_vectors_ID,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_selection:
+ * @image_ID: 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: The selection channel.
+ **/
+gint32
+gimp_image_get_selection (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 selection_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-selection",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    selection_ID = return_vals[1].data.d_selection;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return selection_ID;
+}
+
+/**
+ * gimp_image_get_component_active:
+ * @image_ID: 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 (gint32          image_ID,
+                                 GimpChannelType component)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean active = FALSE;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-component-active",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, component,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    active = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return active;
+}
+
+/**
+ * gimp_image_set_component_active:
+ * @image_ID: 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 (gint32          image_ID,
+                                 GimpChannelType component,
+                                 gboolean        active)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-component-active",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, component,
+                                    GIMP_PDB_INT32, active,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_component_visible:
+ * @image_ID: 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 (gint32          image_ID,
+                                  GimpChannelType component)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean visible = FALSE;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-component-visible",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, component,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    visible = return_vals[1].data.d_int32;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return visible;
+}
+
+/**
+ * gimp_image_set_component_visible:
+ * @image_ID: 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 (gint32          image_ID,
+                                  GimpChannelType component,
+                                  gboolean        visible)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-component-visible",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, component,
+                                    GIMP_PDB_INT32, visible,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_filename:
+ * @image_ID: The image.
+ *
+ * Returns the specified image's filename.
+ *
+ * This procedure returns the specified image's filename in the
+ * filesystem encoding. The image has a filename 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_uri().
+ *
+ * Returns: The filename. The returned value must be freed with
+ * g_free().
+ **/
+gchar *
+gimp_image_get_filename (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *filename = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-filename",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    filename = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return filename;
+}
+
+/**
+ * gimp_image_set_filename:
+ * @image_ID: The image.
+ * @filename: The new image filename.
+ *
+ * Sets the specified image's filename.
+ *
+ * This procedure sets the specified image's filename. The filename
+ * should be in the filesystem encoding.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_set_filename (gint32       image_ID,
+                         const gchar *filename)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-filename",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, filename,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_uri:
+ * @image_ID: The image.
+ *
+ * Returns the URI for the specified image.
+ *
+ * This procedure returns the URI associated with the specified image.
+ * The image has an URI 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-uri to get the URI
+ * of the current file if it was imported from a non-GIMP file format
+ * and not yet saved, or gimp-image-get-exported-uri if the image has
+ * been exported to a non-GIMP file format.
+ *
+ * Returns: The URI. The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_uri (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *uri = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-uri",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    uri = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_xcf_uri:
+ * @image_ID: The image.
+ *
+ * Returns the XCF URI for the specified image.
+ *
+ * This procedure returns the XCF URI associated with the image. If
+ * there is no such URI, this procedure returns %NULL.
+ *
+ * Returns: The imported URI. The returned value must be freed with
+ * g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_xcf_uri (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *uri = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-xcf-uri",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    uri = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_imported_uri:
+ * @image_ID: The image.
+ *
+ * Returns the imported URI for the specified image.
+ *
+ * This procedure returns the URI 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: The imported URI. The returned value must be freed with
+ * g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_imported_uri (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *uri = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-imported-uri",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    uri = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_exported_uri:
+ * @image_ID: The image.
+ *
+ * Returns the exported URI for the specified image.
+ *
+ * This procedure returns the URI 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: The exported URI. The returned value must be freed with
+ * g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_exported_uri (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *uri = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-exported-uri",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    uri = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_name:
+ * @image_ID: 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: The name. The returned value must be freed with g_free().
+ **/
+gchar *
+gimp_image_get_name (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar *name = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-name",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    name = g_strdup (return_vals[1].data.d_string);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return name;
+}
+
+/**
+ * gimp_image_get_resolution:
+ * @image_ID: The image.
+ * @xresolution: The resolution in the x-axis, in dots per inch.
+ * @yresolution: 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 (gint32   image_ID,
+                           gdouble *xresolution,
+                           gdouble *yresolution)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-resolution",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *xresolution = 0.0;
+  *yresolution = 0.0;
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *xresolution = return_vals[1].data.d_float;
+      *yresolution = return_vals[2].data.d_float;
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_set_resolution:
+ * @image_ID: 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 (gint32  image_ID,
+                           gdouble xresolution,
+                           gdouble yresolution)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-resolution",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_FLOAT, xresolution,
+                                    GIMP_PDB_FLOAT, yresolution,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_unit:
+ * @image_ID: 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: The unit.
+ **/
+GimpUnit
+gimp_image_get_unit (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  GimpUnit unit = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-unit",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    unit = return_vals[1].data.d_unit;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return unit;
+}
+
+/**
+ * gimp_image_set_unit:
+ * @image_ID: 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 (gint32   image_ID,
+                     GimpUnit unit)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-unit",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, unit,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_tattoo_state:
+ * @image_ID: 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.
+ **/
+gint
+gimp_image_get_tattoo_state (gint32 image_ID)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint tattoo_state = 0;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-tattoo-state",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    tattoo_state = return_vals[1].data.d_tattoo;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return tattoo_state;
+}
+
+/**
+ * gimp_image_set_tattoo_state:
+ * @image_ID: 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 (gint32 image_ID,
+                             gint   tattoo_state)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-set-tattoo-state",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, tattoo_state,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_layer_by_tattoo:
+ * @image_ID: 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: The layer with the specified tattoo.
+ **/
+gint32
+gimp_image_get_layer_by_tattoo (gint32 image_ID,
+                                gint   tattoo)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-layer-by-tattoo",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, tattoo,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_get_channel_by_tattoo:
+ * @image_ID: 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: The channel with the specified tattoo.
+ **/
+gint32
+gimp_image_get_channel_by_tattoo (gint32 image_ID,
+                                  gint   tattoo)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 channel_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-channel-by-tattoo",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, tattoo,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    channel_ID = return_vals[1].data.d_channel;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return channel_ID;
+}
+
+/**
+ * gimp_image_get_vectors_by_tattoo:
+ * @image_ID: 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: The vectors with the specified tattoo.
+ *
+ * Since: 2.6
+ **/
+gint32
+gimp_image_get_vectors_by_tattoo (gint32 image_ID,
+                                  gint   tattoo)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 vectors_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-vectors-by-tattoo",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_INT32, tattoo,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    vectors_ID = return_vals[1].data.d_vectors;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return vectors_ID;
+}
+
+/**
+ * gimp_image_get_layer_by_name:
+ * @image_ID: 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: The layer with the specified name.
+ *
+ * Since: 2.8
+ **/
+gint32
+gimp_image_get_layer_by_name (gint32       image_ID,
+                              const gchar *name)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 layer_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-layer-by-name",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, name,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    layer_ID = return_vals[1].data.d_layer;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_get_channel_by_name:
+ * @image_ID: 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: The channel with the specified name.
+ *
+ * Since: 2.8
+ **/
+gint32
+gimp_image_get_channel_by_name (gint32       image_ID,
+                                const gchar *name)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 channel_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-channel-by-name",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, name,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    channel_ID = return_vals[1].data.d_channel;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return channel_ID;
+}
+
+/**
+ * gimp_image_get_vectors_by_name:
+ * @image_ID: 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: The vectors with the specified name.
+ *
+ * Since: 2.8
+ **/
+gint32
+gimp_image_get_vectors_by_name (gint32       image_ID,
+                                const gchar *name)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gint32 vectors_ID = -1;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-vectors-by-name",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, name,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    vectors_ID = return_vals[1].data.d_vectors;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return vectors_ID;
+}
+
+/**
+ * gimp_image_attach_parasite:
+ * @image_ID: 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 (gint32              image_ID,
+                            const GimpParasite *parasite)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-attach-parasite",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_PARASITE, parasite,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_detach_parasite:
+ * @image_ID: 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 (gint32       image_ID,
+                            const gchar *name)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gboolean success = TRUE;
+
+  return_vals = gimp_run_procedure ("gimp-image-detach-parasite",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, name,
+                                    GIMP_PDB_END);
+
+  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_parasite:
+ * @image_ID: 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: The found parasite.
+ *
+ * Since: 2.8
+ **/
+GimpParasite *
+gimp_image_get_parasite (gint32       image_ID,
+                         const gchar *name)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  GimpParasite *parasite = NULL;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-parasite",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_STRING, name,
+                                    GIMP_PDB_END);
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return parasite;
+}
+
+/**
+ * gimp_image_get_parasite_list:
+ * @image_ID: The image.
+ * @num_parasites: The number of attached parasites.
+ *
+ * List all parasites.
+ *
+ * Returns a list of all currently attached parasites.
+ *
+ * Returns: The names of currently attached parasites. The returned
+ * value must be freed with g_strfreev().
+ *
+ * Since: 2.8
+ **/
+gchar **
+gimp_image_get_parasite_list (gint32  image_ID,
+                              gint   *num_parasites)
+{
+  GimpParam *return_vals;
+  gint nreturn_vals;
+  gchar **parasites = NULL;
+  gint i;
+
+  return_vals = gimp_run_procedure ("gimp-image-get-parasite-list",
+                                    &nreturn_vals,
+                                    GIMP_PDB_IMAGE, image_ID,
+                                    GIMP_PDB_END);
+
+  *num_parasites = 0;
+
+  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+    {
+      *num_parasites = return_vals[1].data.d_int32;
+      if (*num_parasites > 0)
+        {
+          parasites = g_new0 (gchar *, *num_parasites + 1);
+          for (i = 0; i < *num_parasites; i++)
+            parasites[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
+        }
+    }
+
+  gimp_destroy_params (return_vals, nreturn_vals);
+
+  return parasites;
+}