Adding upstream version 2.10.22.upstream/2.10.22upstream

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

1 files changed, 3208 insertions, 0 deletions

diff --git a/pdb/groups/image.pdb b/pdb/groups/image.pdb
new file mode 100644
index 0000000..9eb7e1a
--- /dev/null
+++ b/pdb/groups/image.pdb
@@ -0,0 +1,3208 @@
+# GIMP - The GNU Image Manipulation Program
+# Copyright (C) 1995 Spencer Kimball and Peter Mattis
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# This program 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 General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# "Perlized" from C source by Manish Singh <yosh@gimp.org>
+
+sub image_is_valid {
+    $blurb = 'Returns TRUE if the image is valid.';
+
+    $help = <<'HELP';
+This procedure checks if the given image ID is valid and refers to an
+existing image.
+HELP
+
+    &neo_pdb_misc('2007', '2.4');
+
+    @inargs = (
+        { name => 'image', type => 'image', no_validate => 1,
+          desc => 'The image to check' }
+    );
+
+    @outargs = (
+        { name => 'valid', type => 'boolean',
+          desc => 'Whether the image ID is valid' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  valid = GIMP_IS_IMAGE (image);
+}
+CODE
+    );
+}
+
+sub image_list {
+    $blurb = 'Returns the list of images currently open.';
+
+    $help = <<'HELP';
+This procedure returns the list of images currently open in GIMP.
+HELP
+
+    &std_pdb_misc;
+
+    @outargs = (
+        { name => 'image_ids', type => 'int32array',
+          desc => 'The list of images currently open. The returned value must be freed with g_free()',
+          array => { name => 'num_images',
+                     desc => 'The number of images currently open' } }
+    );
+
+    %invoke = (
+        code => <<CODE
+{
+  GList *list = gimp_get_image_iter (gimp);
+
+  num_images = g_list_length (list);
+
+  if (num_images)
+    {
+      gint i;
+
+      image_ids = g_new (gint32, num_images);
+
+      for (i = 0; i < num_images; i++, list = g_list_next (list))
+        image_ids[i] = gimp_image_get_ID (GIMP_IMAGE (list->data));
+    }
+}
+CODE
+    );
+}
+
+sub image_new {
+    $blurb = 'Creates a new image with the specified width, height, and type.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
+          desc => 'The width of the image' },
+        { name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
+          desc => 'The height of the image' },
+        { name => 'type', type => 'enum GimpImageBaseType',
+          desc => 'The type of image' }
+    );
+
+    @outargs = (
+        { name => 'image', type => 'image',
+          desc => 'The ID of the newly created image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  image = gimp_create_image (gimp, width, height, type,
+                             GIMP_PRECISION_U8_GAMMA, FALSE);
+
+  if (! image)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_new_with_precision {
+    $blurb = 'Creates a new image with the specified width, height, type and precision.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('2012', '2.10');
+
+    @inargs = (
+        { name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
+          desc => 'The width of the image' },
+        { name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
+          desc => 'The height of the image' },
+        { name => 'type', type => 'enum GimpImageBaseType',
+          desc => 'The type of image' },
+        { name => 'precision', type => 'enum GimpPrecision',
+          desc => 'The precision' }
+    );
+
+    @outargs = (
+        { name => 'image', type => 'image',
+          desc => 'The ID of the newly created image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp->plug_in_manager->current_plug_in)
+    gimp_plug_in_enable_precision (gimp->plug_in_manager->current_plug_in);
+
+  if (gimp_babl_is_valid (type, precision))
+    {
+      image = gimp_create_image (gimp, width, height, type,
+                                 precision, FALSE);
+      if (! image)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_duplicate {
+    $blurb = 'Duplicate the specified image';
+
+    $help = <<'HELP';
+This procedure duplicates the specified image, copying all layers, channels,
+and image information.
+HELP
+
+    &std_pdb_misc;
+    $date = '1997';
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'new_image', type => 'image',
+          desc => 'The new, duplicated image' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-duplicate.h") ],
+        code => <<'CODE'
+{
+  new_image = gimp_image_duplicate (image);
+
+  if (! new_image)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_delete {
+    $blurb = 'Delete the specified image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_image_get_display_count (image) == 0)
+    g_object_unref (image);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_free_shadow {
+    &std_pdb_deprecated ('gimp-drawable-free-shadow');
+
+    @inargs = (
+        { name => 'image', type => 'image', dead => 1,
+          desc => 'The image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+}
+CODE
+    );
+}
+
+sub image_get_layers {
+    $blurb = 'Returns the list of layers contained in the specified image.';
+
+    $help = <<HELP;
+This procedure returns the list of layers contained in the specified image.
+The order of layers is from topmost to bottommost.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'layer_ids', type => 'int32array',
+          desc => 'The list of layers contained in the image. The returned value must be freed with g_free()',
+          array => { name => 'num_layers',
+                     desc => 'The number of layers contained in the image' } }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GList *list = gimp_image_get_layer_iter (image);
+
+  num_layers = g_list_length (list);
+
+  if (num_layers)
+    {
+      gint i;
+
+      layer_ids = g_new (gint32, num_layers);
+
+      for (i = 0; i < num_layers; i++, list = g_list_next (list))
+        layer_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
+    }
+}
+CODE
+    );
+}
+
+sub image_get_channels {
+    $blurb = 'Returns the list of channels contained in the specified image.';
+
+    $help = <<HELP;
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'channel_ids', type => 'int32array',
+          desc => 'The list of channels contained in the image. The returned value must be freed with g_free()',
+          array => { name => 'num_channels',
+                     desc => 'The number of channels contained in the image' } }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GList *list = gimp_image_get_channel_iter (image);
+
+  num_channels = g_list_length (list);
+
+  if (num_channels)
+    {
+      gint i;
+
+      channel_ids = g_new (gint32, num_channels);
+
+      for (i = 0; i < num_channels; i++, list = g_list_next (list))
+        channel_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
+    }
+}
+CODE
+    );
+}
+
+sub image_get_vectors {
+    $blurb = 'Returns the list of vectors contained in the specified image.';
+
+    $help = <<HELP;
+This procedure returns the list of vectors contained in the specified image.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'vector_ids', type => 'int32array',
+          desc => 'The list of vectors contained in the image. The returned value must be freed with g_free()',
+          array => { name => 'num_vectors',
+                     desc => 'The number of vectors contained in the image' } }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GList *list = gimp_image_get_vectors_iter (image);
+
+  num_vectors = g_list_length (list);
+
+  if (num_vectors)
+    {
+      gint i;
+
+      vector_ids = g_new (gint32, num_vectors);
+
+      for (i = 0; i < num_vectors; i++, list = g_list_next (list))
+        vector_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
+    }
+}
+CODE
+    );
+}
+
+sub image_unset_active_channel {
+    $blurb = 'Unsets the active channel in the specified image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_unset_active_channel (image);
+}
+CODE
+    );
+}
+
+sub image_pick_color {
+    $blurb = <<'BLURB';
+Determine the color at the given drawable coordinates
+BLURB
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'drawable', type => 'drawable', none_ok => 1,
+          desc => 'The drawable to pick from' },
+        { name => 'x', type => 'float',
+          desc => 'x coordinate of upper-left corner of rectangle' },
+        { name => 'y', type => 'float',
+          desc => 'y coordinate of upper-left corner of rectangle' },
+        { name => 'sample_merged', type => 'boolean',
+          desc => 'Use the composite image, not the drawable' },
+        { name => 'sample_average', type => 'boolean',
+          desc => 'Average the color of all the pixels in a specified
+                   radius' },
+        { name => 'average_radius', type => '0 < float', no_validate => 1,
+          desc => 'The radius of pixels to average' }
+    );
+
+    @outargs = (
+        { name => 'color', type => 'color', has_alpha => 1, void_ret => 1,
+          desc => 'The return color' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-pick-color.h" "core/gimppickable.h") ],
+        code => <<'CODE'
+{
+  if (!sample_merged)
+    if (!drawable || (gimp_item_get_image (GIMP_ITEM (drawable)) != image))
+      success = FALSE;
+
+  if (success && sample_average)
+    {
+      if (average_radius <= 0.0)
+        success = FALSE;
+    }
+
+  if (success)
+    {
+      if (sample_merged)
+        gimp_pickable_flush (GIMP_PICKABLE (image));
+      else
+        gimp_pickable_flush (GIMP_PICKABLE (drawable));
+
+      success = gimp_image_pick_color (image,
+                                       drawable,
+                                       (gint) x, (gint) y,
+                                       FALSE,
+                                       sample_merged,
+                                       sample_average,
+                                       average_radius,
+                                       NULL,
+                                       NULL,
+                                       &color);
+    }
+}
+CODE
+    );
+}
+
+sub image_pick_correlate_layer {
+    $blurb = 'Find the layer visible at the specified coordinates.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'x', type => 'int32',
+          desc => 'The x coordinate for the pick' },
+        { name => 'y', type => 'int32',
+          desc => 'The y coordinate for the pick' }
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The layer found at the specified coordinates' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-pick-item.h") ],
+        code => <<'CODE'
+{
+  layer = gimp_image_pick_layer (image, x, y, NULL);
+}
+CODE
+    );
+}
+
+sub image_get_item_position {
+    $blurb = 'Returns the position of the item in its level of its item tree.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item' }
+    );
+
+    @outargs = (
+        { name => 'position', type => 'int32',
+          desc => "The position of the item in its level in the item tree" }
+    );
+
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
+    position = gimp_item_get_index (item);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_raise_item {
+    $blurb = "Raise the specified item in its level in its item tree";
+
+    $help = <<'HELP';
+This procedure raises the specified item one step in the item tree.
+The procedure call will fail if there is no item above it.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item to raise' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
+    success = gimp_image_raise_item (image, item, error);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_lower_item {
+    $blurb = "Lower the specified item in its level in its item tree";
+
+    $help = <<'HELP';
+This procedure lowers the specified item one step in the item tree.
+The procedure call will fail if there is no item below it.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item to lower' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
+    success = gimp_image_lower_item (image, item, error);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_raise_item_to_top {
+    $blurb = <<'BLURB';
+Raise the specified item to the top of its level in its item tree
+BLURB
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item to raise to top' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
+    success = gimp_image_raise_item_to_top (image, item);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_lower_item_to_bottom {
+    $blurb = <<'BLURB';
+Lower the specified item to the bottom of its level in its item tree
+BLURB
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item to lower to bottom' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
+    success = gimp_image_lower_item_to_bottom (image, item);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_reorder_item {
+    $blurb = "Reorder the specified item within its item tree";
+
+    $help = <<'HELP';
+This procedure reorders the specified item within its item tree.
+HELP
+
+    &mitch_pdb_misc('2010', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'item', type => 'item',
+          desc => 'The item to reorder' },
+        { name => 'parent', type => 'item', none_ok => 1,
+          desc => 'The new parent item' },
+        { name => 'position', type => 'int32',
+          desc => 'The new position of the item' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_in_tree (item, image, 0, error) &&
+      (parent == NULL ||
+       (gimp_pdb_item_is_in_same_tree (item, parent, image, error) &&
+        gimp_pdb_item_is_group (parent, error) &&
+        gimp_pdb_item_is_not_ancestor (item, parent, error))))
+    {
+      success = gimp_image_reorder_item (image, item, parent, position,
+                                         TRUE, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_merge_visible_layers {
+    $blurb = 'Merge the visible image layers into one.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'merge_type',
+          type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
+          desc => 'The type of merge' }
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The resulting layer' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-merge.h") ],
+        code => <<'CODE'
+{
+  layer = gimp_image_merge_visible_layers (image, context, merge_type,
+                                           FALSE, FALSE,
+                                           progress);
+
+  if (! layer)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_merge_down {
+    $blurb = 'Merge the layer passed and the first visible layer below.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &larry_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'merge_layer', type => 'layer',
+          desc => 'The layer to merge down from' },
+        { name => 'merge_type',
+          type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
+          desc => 'The type of merge' }
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The resulting layer' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-merge.h") ],
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (merge_layer), image, 0, error))
+    {
+      layer = gimp_image_merge_down (image, merge_layer, context, merge_type,
+                                     progress, error);
+
+      if (! layer)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_merge_layer_group {
+    $blurb = 'Merge the passed layer group\'s layers into one normal layer.';
+
+    $help = <<'HELP';
+This procedure combines the layers of the passed layer group into
+a single normal layer, replacing the group.
+HELP
+
+    &ell_pdb_misc('2019', '2.10.14');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer_group', type => 'layer',
+          desc => 'The layer group to merge' },
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The resulting layer' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpgrouplayer.h" "core/gimpimage-merge.h") ],
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer_group), image, 0, error) &&
+      gimp_pdb_item_is_group (GIMP_ITEM (layer_group), error))
+    {
+      layer = gimp_image_merge_group_layer (image,
+                                            GIMP_GROUP_LAYER (layer_group));
+
+      if (! layer)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_flatten {
+    $blurb = <<'BLURB';
+Flatten all visible layers into a single layer. Discard all invisible layers.
+BLURB
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+   );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The resulting layer' }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-merge.h") ],
+        code => <<'CODE'
+{
+  layer = gimp_image_flatten (image, context,
+                              progress, error);
+
+  if (! layer)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_add_layer {
+    &std_pdb_deprecated ('gimp-image-insert-layer');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer', type => 'layer',
+          desc => 'The layer' },
+        { name => 'position', type => 'int32',
+          desc => 'The layer position' }
+    );
+
+    $invoke{code} = <<'CODE';
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (layer), image, error) &&
+      gimp_pdb_image_is_base_type (image,
+                                   gimp_drawable_get_base_type (GIMP_DRAWABLE (layer)),
+                                   error))
+    {
+      success = gimp_image_add_layer (image, layer,
+                                      NULL, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+}
+
+sub image_insert_layer {
+    $blurb = 'Add the specified layer to the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer', type => 'layer',
+          desc => 'The layer' },
+        { name => 'parent', type => 'layer', none_ok => 1,
+          desc => 'The parent layer' },
+        { name => 'position', type => 'int32',
+          desc => 'The layer position' }
+    );
+
+    $invoke{code} = <<'CODE';
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (layer), image, error) &&
+      gimp_pdb_image_is_base_type (image,
+                                   gimp_drawable_get_base_type (GIMP_DRAWABLE (layer)),
+                                   error) &&
+      (parent == NULL ||
+       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
+        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
+    {
+      if (position == -1 && parent == NULL)
+        parent = GIMP_IMAGE_ACTIVE_PARENT;
+
+      success = gimp_image_add_layer (image, layer,
+                                      parent, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+}
+
+sub image_remove_layer {
+    $blurb = 'Remove the specified layer from the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer', type => 'layer',
+          desc => 'The layer' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), image, 0, error))
+    gimp_image_remove_layer (image, layer, TRUE, NULL);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_add_layer_mask {
+    &std_pdb_deprecated ('gimp-layer-add-mask');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer', type => 'layer',
+          desc => 'The layer to receive the mask' },
+        { name => 'mask', type => 'layer_mask',
+          desc => 'The mask to add to the layer' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (mask), image, error) &&
+      gimp_pdb_item_is_not_group (GIMP_ITEM (layer), error))
+    success = (gimp_layer_add_mask (layer, mask, TRUE, error) == mask);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_remove_layer_mask {
+    &std_pdb_deprecated ('gimp-layer-remove-mask');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'layer', type => 'layer',
+          desc => 'The layer from which to remove mask' },
+        { name => 'mode', type => 'enum GimpMaskApplyMode',
+          desc => 'Removal mode' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpPDBItemModify modify = 0;
+
+  if (mode == GIMP_MASK_APPLY)
+    modify |= GIMP_PDB_ITEM_CONTENT;
+
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), image, modify, error) &&
+      gimp_layer_get_mask (layer))
+    gimp_layer_apply_mask (layer, mode, TRUE);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_freeze_layers {
+    $blurb = "Freeze the image's layer list.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_layers (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_layers_freeze (plug_in, image);
+
+  if (success)
+    gimp_container_freeze (container);
+}
+CODE
+    );
+}
+
+sub image_thaw_layers {
+    $blurb = "Thaw the image's layer list.";
+
+    $help = <<'HELP';
+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().
+HELP
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_layers (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_layers_thaw (plug_in, image);
+
+  if (success)
+    success = gimp_container_frozen (container);
+
+  if (success)
+    gimp_container_thaw (container);
+}
+CODE
+    );
+}
+
+sub image_add_channel {
+    &std_pdb_deprecated ('gimp-image-insert-channel');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'channel', type => 'channel',
+          desc => 'The channel' },
+        { name => 'position', type => 'int32',
+          desc => 'The channel position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (channel), image, error))
+    {
+      success = gimp_image_add_channel (image, channel,
+                                        NULL, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+    );
+}
+
+sub image_insert_channel {
+    $blurb = 'Add the specified channel to the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'channel', type => 'channel',
+          desc => 'The channel' },
+        { name => 'parent', type => 'channel', none_ok => 1,
+          desc => 'The parent channel' },
+        { name => 'position', type => 'int32',
+          desc => 'The channel position' }
+    );
+
+    $invoke{code} = <<'CODE';
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (channel), image, error) &&
+      (parent == NULL ||
+       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
+        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
+    {
+      if (position == -1 && parent == NULL)
+        parent = GIMP_IMAGE_ACTIVE_PARENT;
+
+      success = gimp_image_add_channel (image, channel,
+                                        parent, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+}
+
+sub image_remove_channel {
+    $blurb = 'Remove the specified channel from the image.';
+
+    $help = <<'HELP';
+This procedure removes the specified channel from the image. If the channel
+doesn't exist, an error is returned.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'channel', type => 'channel',
+          desc => 'The channel' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (channel), image, 0, error))
+    gimp_image_remove_channel (image, channel, TRUE, NULL);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_freeze_channels {
+    $blurb = "Freeze the image's channel list.";
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    $help = <<'HELP';
+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.
+HELP
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_channels (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_channels_freeze (plug_in, image);
+
+  if (success)
+    gimp_container_freeze (container);
+}
+CODE
+    );
+}
+
+sub image_thaw_channels {
+    $blurb = "Thaw the image's channel list.";
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    $help = <<'HELP';
+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().
+HELP
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_channels (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_channels_thaw (plug_in, image);
+
+  if (success)
+    success = gimp_container_frozen (container);
+
+  if (success)
+    gimp_container_thaw (container);
+}
+CODE
+    );
+}
+
+sub image_add_vectors {
+    &std_pdb_deprecated ('gimp-image-insert-vectors');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors object' },
+        { name => 'position', type => 'int32',
+          desc => 'The vectors objects position' }
+    );
+
+    $invoke{code} = <<'CODE';
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (vectors), image, error))
+    {
+      success = gimp_image_add_vectors (image, vectors,
+                                        NULL, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+}
+
+sub image_insert_vectors {
+    $blurb = 'Add the specified vectors to the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors' },
+        { name => 'parent', type => 'vectors', none_ok => 1,
+          desc => 'The parent vectors' },
+        { name => 'position', type => 'int32',
+          desc => 'The vectors position' }
+    );
+
+    $invoke{code} = <<'CODE';
+{
+  if (gimp_pdb_item_is_floating (GIMP_ITEM (vectors), image, error) &&
+      (parent == NULL ||
+       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
+        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
+    {
+      if (position == -1 && parent == NULL)
+        parent = GIMP_IMAGE_ACTIVE_PARENT;
+
+      success = gimp_image_add_vectors (image, vectors,
+                                        parent, MAX (position, -1), TRUE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+}
+
+sub image_remove_vectors {
+    $blurb = 'Remove the specified path from the image.';
+
+    $help = <<'HELP';
+This procedure removes the specified path from the image. If the path
+doesn't exist, an error is returned.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors object' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (vectors), image, 0, error))
+    gimp_image_remove_vectors (image, vectors, TRUE, NULL);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_freeze_vectors {
+    $blurb = "Freeze the image's vectors list.";
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    $help = <<'HELP';
+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.
+HELP
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_vectors (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_vectors_freeze (plug_in, image);
+
+  if (success)
+    gimp_container_freeze (container);
+}
+CODE
+    );
+}
+
+sub image_thaw_vectors {
+    $blurb = "Thaw the image's vectors list.";
+
+    &ell_pdb_misc('2018', '2.10.2');
+
+    $help = <<'HELP';
+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().
+HELP
+
+    @inargs = (
+    { name => 'image', type => 'image',
+      desc => 'The image' }
+    );
+
+    %invoke = (
+    code => <<'CODE'
+{
+  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
+  GimpContainer *container = gimp_image_get_vectors (image);
+
+  if (plug_in)
+    success = gimp_plug_in_cleanup_vectors_thaw (plug_in, image);
+
+  if (success)
+    success = gimp_container_frozen (container);
+
+  if (success)
+    gimp_container_thaw (container);
+}
+CODE
+    );
+}
+
+sub image_get_active_drawable {
+    $blurb = "Get the image's active drawable";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'drawable', type => 'drawable',
+          desc => 'The active drawable' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  drawable = gimp_image_get_active_drawable (image);
+}
+CODE
+    );
+}
+
+sub image_base_type {
+    $blurb = 'Get the base type of the image.';
+
+    $help = <<'HELP';
+This procedure returns the image's base type. Layers in the image must be of
+this subtype, but can have an optional alpha channel.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'base_type', type => 'enum GimpImageBaseType',
+          desc => "The image's base type" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  base_type = gimp_image_get_base_type (image);
+}
+CODE
+    );
+}
+
+sub image_get_precision {
+    $blurb = 'Get the precision of the image.';
+
+    $help = <<'HELP';
+This procedure returns the image's precision.
+HELP
+
+    &mitch_pdb_misc('2012', '2.10');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'precision', type => 'enum GimpPrecision',
+          desc => "The image's precision" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp->plug_in_manager->current_plug_in)
+    gimp_plug_in_enable_precision (gimp->plug_in_manager->current_plug_in);
+
+  precision = gimp_image_get_precision (image);
+}
+CODE
+    );
+}
+
+sub image_get_default_new_layer_mode {
+    $blurb = 'Get the default mode for newly created layers of this image.';
+    $help  = 'Returns the default mode for newly created layers of this image.';
+
+    &mitch_pdb_misc('2017', '2.10');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+	{ name => 'mode', type => 'enum GimpLayerMode',
+          default => 'GIMP_LAYER_MODE_NORMAL',
+	  desc => 'The layer mode' }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  mode = gimp_image_get_default_new_layer_mode (image);
+}
+CODE
+    );
+}
+
+sub image_get_colormap {
+    $blurb = "Returns the image's colormap";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'colormap', type => 'int8array', wrap => 1,
+          desc => "The image's colormap. The returned value must be freed with g_free()",
+          array => { name => 'num_bytes',
+                     desc => 'Number of bytes in the colormap array' } }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-colormap.h") ],
+        code => <<'CODE'
+{
+  num_bytes = 3 * gimp_image_get_colormap_size (image);
+  colormap = g_memdup (gimp_image_get_colormap (image), num_bytes);
+}
+CODE
+    );
+}
+
+sub image_set_colormap {
+    $blurb = "Sets the entries in the image's colormap.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'colormap', type => 'int8array', wrap => 1,
+          desc => 'The new colormap values',
+          array => { name => 'num_bytes', type => '0 <= int32 <= 768',
+                     desc => 'Number of bytes in the colormap array' } }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimpimage-colormap.h") ],
+        code => <<'CODE'
+{
+  gimp_image_set_colormap (image, colormap, num_bytes / 3, TRUE);
+}
+CODE
+    );
+}
+
+sub image_get_metadata {
+    $blurb = "Returns the image's metadata.";
+    $help  = 'Returns exif/iptc/xmp metadata from the image.';
+
+    &std_pdb_misc('2013', '2.10');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+	{ name => 'metadata_string', type => 'string', wrap => 1,
+	  desc => 'The exif/ptc/xmp metadata as a string'}
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpMetadata *metadata = gimp_image_get_metadata (image);
+
+  if (metadata)
+    metadata_string = gimp_metadata_serialize (metadata);
+}
+CODE
+    );
+}
+
+sub image_set_metadata {
+    $blurb = "Set the image's metadata.";
+    $help  = 'Sets exif/iptc/xmp metadata on the image.';
+
+    &std_pdb_misc('2013', '2.10');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+	{ name => 'metadata_string', type => 'string', wrap => 1,
+	  desc => 'The exif/ptc/xmp metadata as a string' }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpMetadata *metadata = gimp_metadata_deserialize (metadata_string);
+
+  gimp_image_set_metadata (image, metadata, TRUE);
+
+  if (metadata)
+    g_object_unref (metadata);
+}
+CODE
+    );
+}
+
+sub image_clean_all {
+    $blurb = 'Set the image dirty count to 0.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_clean_all (image);
+}
+CODE
+    );
+}
+
+sub image_is_dirty {
+    $blurb = 'Checks if the image has unsaved changes.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'dirty', type => 'boolean',
+          desc => 'TRUE if the image has unsaved changes.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  dirty = gimp_image_is_dirty (image);
+}
+CODE
+    );
+}
+
+sub image_get_floating_sel {
+    $blurb = 'Return the floating selection of the image.';
+
+    $help = <<'HELP';
+This procedure returns the image's floating selection, if it exists.
+If it doesn't exist, -1 is returned as the layer ID.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'floating_sel', type => 'layer',
+          desc => "The image's floating selection" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  floating_sel = gimp_image_get_floating_selection (image);
+}
+CODE
+    );
+}
+
+sub image_floating_sel_attached_to {
+    $blurb = 'Return the drawable the floating selection is attached to.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &wolfgang_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'drawable', type => 'drawable',
+          desc => 'The drawable the floating selection is attached to' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpLayer *floating_sel = gimp_image_get_floating_selection (image);
+
+  if (floating_sel)
+    drawable = gimp_layer_get_floating_sel_drawable (floating_sel);
+  else
+    drawable = NULL;
+}
+CODE
+    );
+}
+
+sub image_width {
+    $blurb = 'Return the width of the image';
+
+    $help = <<'HELP';
+This procedure returns the image's width. This value is independent of any of
+the layers in this image. This is the "canvas" width.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'width', type => 'int32',
+          desc => "The image's width" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  width = gimp_image_get_width (image);
+}
+CODE
+    );
+}
+
+sub image_height {
+    $blurb = 'Return the height of the image';
+
+    $help = <<'HELP';
+This procedure returns the image's height. This value is independent of any of
+the layers in this image. This is the "canvas" height.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'height', type => 'int32',
+          desc => "The image's height" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  height = gimp_image_get_height (image);
+}
+CODE
+    );
+}
+
+sub image_get_active_layer {
+    $blurb = "Returns the specified image's active layer.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'active_layer', type => 'layer',
+          desc => 'The active layer' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  active_layer = gimp_image_get_active_layer (image);
+}
+CODE
+    );
+}
+
+sub image_set_active_layer {
+    $blurb = "Sets the specified image's active layer.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'active_layer', type => 'layer',
+          desc => 'The new image active layer' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_image_set_active_layer (image, active_layer) != active_layer)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_get_active_channel {
+    $blurb = "Returns the specified image's active channel.";
+
+    $help = <<'HELP';
+If there is an active channel, this will return the channel ID, otherwise, -1.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'active_channel', type => 'channel',
+          desc => 'The active channel' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  active_channel = gimp_image_get_active_channel (image);
+}
+CODE
+    );
+}
+
+sub image_set_active_channel {
+    $blurb = "Sets the specified image's active channel.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'active_channel', type => 'channel',
+          desc => 'The new image active channel' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_image_set_active_channel (image, active_channel) != active_channel)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_get_active_vectors {
+    $blurb = "Returns the specified image's active vectors.";
+
+    $help = <<'HELP';
+If there is an active path, its ID will be returned, otherwise, -1.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'active_vectors', type => 'vectors',
+          desc => 'The active vectors' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  active_vectors = gimp_image_get_active_vectors (image);
+}
+CODE
+    );
+}
+
+sub image_set_active_vectors {
+    $blurb = "Sets the specified image's active vectors.";
+
+    $help = <<'HELP';
+If the path exists, it is set as the active path in the image.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'active_vectors', type => 'vectors',
+          desc => 'The new image active vectors' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_image_set_active_vectors (image, active_vectors) != active_vectors)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_get_selection {
+    $blurb = "Returns the specified image's selection.";
+
+    $help = <<'HELP';
+This will always return a valid ID for a selection -- which is represented as a
+channel internally.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'selection', type => 'selection',
+          desc => 'The selection channel' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  selection = GIMP_SELECTION (gimp_image_get_mask (image));
+
+  if (! selection)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_get_component_active {
+    $blurb = "Returns if the specified image's image component is active.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'component', type => 'enum GimpChannelType',
+          desc => 'The image component' }
+    );
+
+    @outargs = (
+        { name => 'active', type => 'boolean',
+          desc => 'Component is active' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (component == GIMP_CHANNEL_GRAY)
+    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
+  else if (component == GIMP_CHANNEL_INDEXED)
+    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
+  else
+    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
+
+  if (success)
+    active = gimp_image_get_component_active (image, component);
+}
+CODE
+    );
+}
+
+sub image_set_component_active {
+    $blurb = "Sets if the specified image's image component is active.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'component', type => 'enum GimpChannelType',
+          desc => 'The image component' },
+        { name => 'active', type => 'boolean',
+          desc => 'Component is active' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (component == GIMP_CHANNEL_GRAY)
+    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
+  else if (component == GIMP_CHANNEL_INDEXED)
+    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
+  else
+    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
+
+  if (success)
+    gimp_image_set_component_active (image, component, active);
+}
+CODE
+    );
+}
+
+sub image_get_component_visible {
+    $blurb = "Returns if the specified image's image component is visible.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'component', type => 'enum GimpChannelType',
+          desc => 'The image component' }
+    );
+
+    @outargs = (
+        { name => 'visible', type => 'boolean',
+          desc => 'Component is visible' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (component == GIMP_CHANNEL_GRAY)
+    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
+  else if (component == GIMP_CHANNEL_INDEXED)
+    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
+  else
+    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
+
+  if (success)
+    visible = gimp_image_get_component_visible (image, component);
+}
+CODE
+    );
+}
+
+sub image_set_component_visible {
+    $blurb = "Sets if the specified image's image component is visible.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'component', type => 'enum GimpChannelType',
+          desc => 'The image component' },
+        { name => 'visible', type => 'boolean',
+          desc => 'Component is visible' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (component == GIMP_CHANNEL_GRAY)
+    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
+  else if (component == GIMP_CHANNEL_INDEXED)
+    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
+  else
+    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
+
+  if (success)
+    gimp_image_set_component_visible (image, component, visible);
+}
+CODE
+    );
+}
+
+sub image_get_filename {
+    $blurb = "Returns the specified image's filename.";
+
+    $help = <<'HELP';
+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().
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'filename', type => 'string',
+          desc => 'The filename. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GFile *file = gimp_image_get_any_file (image);
+  if (file)
+    filename = g_file_get_path (file);
+}
+CODE
+    );
+}
+
+sub image_set_filename {
+    $blurb = "Sets the specified image's filename.";
+
+    $help = <<'HELP';
+This procedure sets the specified image's filename. The filename
+should be in the filesystem encoding.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'filename', type => 'string',
+          desc => 'The new image filename', allow_non_utf8 => 1 }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  /*  verify that the filename can be converted to UTF-8 and back  */
+  gchar *utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, error);
+
+  if (utf8)
+    {
+      gchar *tmp = g_filename_from_utf8 (utf8, -1, NULL, NULL, error);
+
+      if (tmp)
+        g_free (tmp);
+      else
+        success = FALSE;
+
+      g_free (utf8);
+    }
+  else
+    success = FALSE;
+
+  if (success)
+    {
+      GFile *file = NULL;
+
+      if (filename && strlen (filename))
+        file = file_utils_filename_to_file (image->gimp, filename, NULL);
+
+      gimp_image_set_file (image, file);
+
+      if (file)
+        g_object_unref (file);
+    }
+}
+CODE
+    );
+}
+
+sub image_get_uri {
+    $blurb = "Returns the URI for the specified image.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &neo_pdb_misc('2009', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'uri', type => 'string',
+          desc => 'The URI. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GFile *file = gimp_image_get_any_file (image);
+  if (file)
+    uri = g_file_get_uri (file);
+}
+CODE
+    );
+}
+
+sub image_get_xcf_uri {
+    $blurb = "Returns the XCF URI for the specified image.";
+
+    $help = <<'HELP';
+This procedure returns the XCF URI associated with the image. If
+there is no such URI, this procedure returns %NULL.
+HELP
+
+    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
+    $copyright = 'Eric Grivel';
+    $date = '2011';
+    $since = '2.8';
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'uri', type => 'string',
+          desc => 'The imported URI. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GFile *file = gimp_image_get_file (image);
+  if (file)
+    uri = g_file_get_uri (file);
+}
+CODE
+    );
+}
+
+sub image_get_imported_uri {
+    $blurb = "Returns the imported URI for the specified image.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
+    $copyright = 'Eric Grivel';
+    $date = '2011';
+    $since = '2.8';
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'uri', type => 'string',
+          desc => 'The imported URI. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GFile *file = gimp_image_get_imported_file (image);
+  if (file)
+    uri = g_file_get_uri (file);
+}
+CODE
+    );
+}
+
+sub image_get_exported_uri {
+    $blurb = "Returns the exported URI for the specified image.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
+    $copyright = 'Eric Grivel';
+    $date = '2011';
+    $since = '2.8';
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'uri', type => 'string',
+          desc => 'The exported URI. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GFile *file = gimp_image_get_exported_file (image);
+  if (file)
+    uri = g_file_get_uri (file);
+}
+CODE
+    );
+}
+
+sub image_get_name {
+    $blurb = "Returns the specified image's name.";
+    $help  =  <<'HELP';
+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.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'name', type => 'string',
+          desc => 'The name. The returned value must be freed with g_free()' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  name = g_strdup (gimp_image_get_display_name (image));
+}
+CODE
+    );
+}
+
+sub image_get_resolution {
+    $blurb = "Returns the specified image's resolution.";
+
+    $help = <<'HELP';
+This procedure returns the specified image's resolution in dots per inch.
+This value is independent of any of the layers in this image.
+HELP
+
+    &austin_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'xresolution', type => 'float', void_ret => 1,
+          desc => 'The resolution in the x-axis, in dots per inch' },
+        { name => 'yresolution', type => 'float',
+          desc => 'The resolution in the y-axis, in dots per inch' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_get_resolution (image, &xresolution, &yresolution);
+}
+CODE
+    );
+}
+
+sub image_set_resolution {
+    $blurb = "Sets the specified image's resolution.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &austin_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'xresolution', type => 'float',
+          desc => 'The new image resolution in the x-axis, in dots per inch' },
+        { name => 'yresolution', type => 'float',
+          desc => 'The new image resolution in the y-axis, in dots per inch' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (! FINITE (xresolution) ||
+      xresolution < GIMP_MIN_RESOLUTION || xresolution > GIMP_MAX_RESOLUTION ||
+      ! FINITE (yresolution) ||
+      yresolution < GIMP_MIN_RESOLUTION || yresolution > GIMP_MAX_RESOLUTION)
+    {
+      g_set_error_literal (error, GIMP_PDB_ERROR,
+                           GIMP_PDB_ERROR_INVALID_ARGUMENT,
+                           _("Image resolution is out of bounds, "
+                             "using the default resolution instead."));
+      success = FALSE;
+    }
+  else
+    {
+      gimp_image_set_resolution (image, xresolution, yresolution);
+    }
+}
+CODE
+    );
+}
+
+sub image_get_unit {
+    $blurb = "Returns the specified image's unit.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'unit', type => 'unit',
+          desc => 'The unit' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  unit = gimp_image_get_unit (image);
+}
+CODE
+    );
+}
+
+sub image_set_unit {
+    $blurb = "Sets the specified image's unit.";
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &mitch_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'unit', type => 'unit (min GIMP_UNIT_INCH)',
+          desc => 'The new image unit' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_set_unit (image, unit);
+}
+CODE
+    );
+}
+
+sub image_get_tattoo_state {
+    $blurb = 'Returns the tattoo state associated with the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &andy_pdb_misc('2000');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'tattoo_state', type => 'tattoo',
+          desc => 'The tattoo state' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  tattoo_state = gimp_image_get_tattoo_state (image);
+}
+CODE
+    );
+}
+
+sub image_set_tattoo_state {
+    $blurb = 'Set the tattoo state associated with the image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &andy_pdb_misc('2000');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'tattoo_state', type => 'tattoo',
+          desc => 'The new image tattoo state' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_set_tattoo_state (image, tattoo_state);
+}
+CODE
+    );
+}
+
+sub image_get_layer_by_tattoo {
+    $blurb = 'Find a layer with a given tattoo in an image.';
+
+    $help = <<'HELP';
+This procedure returns the layer with the given tattoo in the specified image.
+HELP
+
+    &jay_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'tattoo', type => 'tattoo',
+          desc => 'The tattoo of the layer to find' }
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The layer with the specified tattoo' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  layer = gimp_image_get_layer_by_tattoo (image, tattoo);
+}
+CODE
+    );
+}
+
+sub image_get_channel_by_tattoo {
+    $blurb = 'Find a channel with a given tattoo in an image.';
+
+    $help = <<'HELP';
+This procedure returns the channel with the given tattoo in the specified image.
+HELP
+
+    &jay_pdb_misc('1998');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'tattoo', type => 'tattoo',
+          desc => 'The tattoo of the channel to find' }
+    );
+
+    @outargs = (
+        { name => 'channel', type => 'channel',
+          desc => 'The channel with the specified tattoo' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  channel = gimp_image_get_channel_by_tattoo (image, tattoo);
+}
+CODE
+    );
+}
+
+sub image_get_vectors_by_tattoo {
+    $blurb = 'Find a vectors with a given tattoo in an image.';
+
+    $help = <<'HELP';
+This procedure returns the vectors with the given tattoo in the
+specified image.
+HELP
+
+    &simon_pdb_misc('2005', '2.6');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'tattoo', type => 'tattoo',
+          desc => 'The tattoo of the vectors to find' }
+    );
+
+    @outargs = (
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors with the specified tattoo' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  vectors = gimp_image_get_vectors_by_tattoo (image, tattoo);
+}
+CODE
+    );
+}
+
+sub image_get_layer_by_name {
+    $blurb = 'Find a layer with a given name in an image.';
+
+    $help = <<'HELP';
+This procedure returns the layer with the given name in the specified image.
+HELP
+
+    &mitch_pdb_misc('2011', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'name', type => 'string', non_empty => 1,
+          desc => 'The name of the layer to find' }
+    );
+
+    @outargs = (
+        { name => 'layer', type => 'layer',
+          desc => 'The layer with the specified name' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  layer = gimp_image_get_layer_by_name (image, name);
+}
+CODE
+    );
+}
+
+sub image_get_channel_by_name {
+    $blurb = 'Find a channel with a given name in an image.';
+
+    $help = <<'HELP';
+This procedure returns the channel with the given name in the specified image.
+HELP
+
+    &mitch_pdb_misc('2011', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'name', type => 'string', non_empty => 1,
+          desc => 'The name of the channel to find' }
+    );
+
+    @outargs = (
+        { name => 'channel', type => 'channel',
+          desc => 'The channel with the specified name' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  channel = gimp_image_get_channel_by_name (image, name);
+}
+CODE
+    );
+}
+
+sub image_get_vectors_by_name {
+    $blurb = 'Find a vectors with a given name in an image.';
+
+    $help = <<'HELP';
+This procedure returns the vectors with the given name in the
+specified image.
+HELP
+
+    &mitch_pdb_misc('2011', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'name', type => 'string', non_empty => 1,
+          desc => 'The name of the vectors to find' }
+    );
+
+    @outargs = (
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors with the specified name' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  vectors = gimp_image_get_vectors_by_name (image, name);
+}
+CODE
+    );
+}
+
+sub image_attach_parasite {
+    $blurb = 'Add a parasite to an image.';
+
+    $help = <<'HELP';
+This procedure attaches a parasite to an image. It has no return values.
+HELP
+
+    &jay_pdb_misc('1998', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'parasite', type => 'parasite',
+          desc => 'The parasite to attach to an image' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_image_parasite_validate (image, parasite, error))
+    gimp_image_parasite_attach (image, parasite, TRUE);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_detach_parasite {
+    $blurb = 'Removes a parasite from an image.';
+
+    $help = <<'HELP';
+This procedure detaches a parasite from an image. It has no return values.
+HELP
+
+    &jay_pdb_misc('1998', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'name', type => 'string',
+          desc => 'The name of the parasite to detach from an image.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  gimp_image_parasite_detach (image, name, TRUE);
+}
+CODE
+    );
+}
+
+sub image_get_parasite {
+    $blurb = 'Look up a parasite in an image';
+
+    $help = <<'HELP';
+Finds and returns the parasite that was previously attached to an image.
+HELP
+
+    &jay_pdb_misc('1998', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'name', type => 'string',
+          desc => 'The name of the parasite to find' }
+    );
+
+    @outargs = (
+        { name => 'parasite', type => 'parasite',
+          desc => 'The found parasite' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  parasite = gimp_parasite_copy (gimp_image_parasite_find (image, name));
+
+  if (! parasite)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub image_get_parasite_list {
+    $blurb = 'List all parasites.';
+    $help  = 'Returns a list of all currently attached parasites.';
+
+    &marc_pdb_misc('1999', '2.8');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' }
+    );
+
+    @outargs = (
+        { name => 'parasites', type => 'stringarray',
+          desc => 'The names of currently attached parasites',
+          array => { desc => 'The number of attached parasites' } }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  parasites = gimp_image_parasite_list (image, &num_parasites);
+}
+CODE
+    );
+}
+
+sub image_thumbnail {
+    $blurb = 'Get a thumbnail of an image.';
+
+    $help = <<'HELP';
+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.
+HELP
+
+    &andy_pdb_misc('1999');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'width', type => '1 <= int32 <= 1024',
+          desc => 'The requested thumbnail width' },
+        { name => 'height', type => '1 <= int32 <= 1024',
+          desc => 'The requested thumbnail height' }
+    );
+
+    @outargs = (
+        { name => 'actual_width', type => 'int32', void_ret => 1,
+          desc => 'The previews width' },
+        { name => 'actual_height', type => 'int32',
+          desc => 'The previews height' },
+        { name => 'bpp', type => 'int32',
+          desc => 'The previews bpp' },
+        { name => 'thumbnail_data', type => 'int8array', wrap => 1,
+          desc => 'The thumbnail data',
+          array => { name => 'thumbnail_data_count',
+                     desc => 'The number of bytes in thumbnail data' } }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpTempBuf *buf;
+  gint         dwidth, dheight;
+
+  gimp_assert (GIMP_VIEWABLE_MAX_PREVIEW_SIZE >= 1024);
+
+  /* Adjust the width/height ratio */
+  dwidth  = gimp_image_get_width  (image);
+  dheight = gimp_image_get_height (image);
+
+  if (dwidth > dheight)
+    height = MAX (1, (width * dheight) / dwidth);
+  else
+    width  = MAX (1, (height * dwidth) / dheight);
+
+  gimp_pickable_flush (GIMP_PICKABLE (image));
+
+  buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (image), context,
+                                       width, height);
+
+  if (buf)
+    {
+      actual_width         = gimp_temp_buf_get_width  (buf);
+      actual_height        = gimp_temp_buf_get_height (buf);
+      bpp                  = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
+      thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
+      thumbnail_data       = g_memdup (gimp_temp_buf_get_data (buf),
+                                       thumbnail_data_count);
+
+      gimp_temp_buf_unref (buf);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+
+$extra{app}->{code} = <<'CODE';
+#if defined (HAVE_ISFINITE)
+#define FINITE(x) isfinite(x)
+#elif defined (HAVE_FINITE)
+#define FINITE(x) finite(x)
+#elif defined (G_OS_WIN32)
+#define FINITE(x) _finite(x)
+#else
+#error "no FINITE() implementation available?!"
+#endif
+CODE
+
+@headers = qw("libgimpmath/gimpmath.h"
+              "libgimpbase/gimpbase.h"
+              "gegl/gimp-babl.h"
+              "core/gimp.h"
+              "core/gimpcontainer.h"
+              "core/gimpimage-metadata.h"
+              "core/gimpprogress.h"
+              "core/gimptempbuf.h"
+              "file/file-utils.h"
+              "plug-in/gimpplugin.h"
+              "plug-in/gimpplugin-cleanup.h"
+              "plug-in/gimppluginmanager.h"
+              "gimppdbcontext.h"
+              "gimppdberror.h"
+              "gimppdb-utils.h"
+              "gimp-intl.h");
+
+@procs = qw(image_is_valid
+            image_list
+            image_new image_new_with_precision
+            image_duplicate image_delete
+            image_base_type
+            image_get_precision
+            image_get_default_new_layer_mode
+            image_width image_height
+            image_free_shadow
+            image_get_layers
+            image_get_channels
+            image_get_vectors
+            image_get_active_drawable
+            image_unset_active_channel
+            image_get_floating_sel
+            image_floating_sel_attached_to
+            image_pick_color
+            image_pick_correlate_layer
+            image_add_layer image_insert_layer image_remove_layer
+            image_freeze_layers image_thaw_layers
+            image_add_channel image_insert_channel image_remove_channel
+            image_freeze_channels image_thaw_channels
+            image_add_vectors image_insert_vectors image_remove_vectors
+            image_freeze_vectors image_thaw_vectors
+            image_get_item_position
+            image_raise_item image_lower_item
+            image_raise_item_to_top image_lower_item_to_bottom
+            image_reorder_item
+            image_flatten image_merge_visible_layers image_merge_down
+            image_merge_layer_group
+            image_add_layer_mask image_remove_layer_mask
+            image_get_colormap image_set_colormap
+            image_get_metadata image_set_metadata
+            image_clean_all image_is_dirty
+            image_thumbnail
+            image_get_active_layer image_set_active_layer
+            image_get_active_channel image_set_active_channel
+            image_get_active_vectors image_set_active_vectors
+            image_get_selection
+            image_get_component_active image_set_component_active
+            image_get_component_visible image_set_component_visible
+            image_get_filename image_set_filename
+            image_get_uri
+            image_get_xcf_uri
+            image_get_imported_uri
+            image_get_exported_uri
+            image_get_name
+            image_get_resolution image_set_resolution
+            image_get_unit image_set_unit
+            image_get_tattoo_state image_set_tattoo_state
+            image_get_layer_by_tattoo
+            image_get_channel_by_tattoo
+            image_get_vectors_by_tattoo
+            image_get_layer_by_name
+            image_get_channel_by_name
+            image_get_vectors_by_name
+            image_attach_parasite image_detach_parasite
+            image_get_parasite
+            image_get_parasite_list);
+
+# For the lib parameter EXCLUDE functions #46 and #47, which are
+# image_add_layer_mask and image_remove_layer_mask.
+# If adding or removing functions, make sure the range below is
+# updated correctly!
+%exports = (app => [@procs], lib => [@procs[0..45,48..88]]);
+
+$desc = 'Image';
+$doc_title = 'gimpimage';
+$doc_short_desc = 'Operations on complete images.';
+$doc_long_desc = 'Operations on complete images: creation, resizing/rescaling, and operations involving multiple layers.';
+
+1;