[gimp/wip/Jehan/classy-GIMP: 6/55] libgimp: generate functions both for old and new GimpImage APIs.



commit 500af13fe3a4843d2f82df50c29ca6370900f521
Author: Jehan <jehan girinstud io>
Date:   Mon Aug 12 14:44:07 2019 +0200

    libgimp: generate functions both for old and new GimpImage APIs.
    
    This way, it would still be possible to use the old API. WIP.

 libgimp/gimpchannel_pdb.c           |  111 +
 libgimp/gimpchannel_pdb.h           |   61 +-
 libgimp/gimpdisplay_pdb.c           |   88 +
 libgimp/gimpdisplay_pdb.h           |   19 +-
 libgimp/gimpedit_pdb.c              |  182 +-
 libgimp/gimpedit_pdb.h              |   41 +-
 libgimp/gimpfileops_pdb.c           |  263 +-
 libgimp/gimpfileops_pdb.h           |   22 +
 libgimp/gimpimage_pdb.c             | 5713 +++++++++++++++++++++++++++++------
 libgimp/gimpimage_pdb.h             |  557 +++-
 libgimp/gimpimagecolorprofile_pdb.c |  310 ++
 libgimp/gimpimagecolorprofile_pdb.h |   60 +-
 libgimp/gimpimageconvert_pdb.c      |  193 ++
 libgimp/gimpimageconvert_pdb.h      |   45 +-
 libgimp/gimpimagegrid_pdb.c         |  463 +++
 libgimp/gimpimagegrid_pdb.h         |   79 +-
 libgimp/gimpimageguides_pdb.c       |  262 ++
 libgimp/gimpimageguides_pdb.h       |   42 +-
 libgimp/gimpimagesamplepoints_pdb.c |  193 ++
 libgimp/gimpimagesamplepoints_pdb.h |   34 +-
 libgimp/gimpimageselect_pdb.c       |  446 +++
 libgimp/gimpimageselect_pdb.h       |  115 +-
 libgimp/gimpimagetransform_pdb.c    |  284 ++
 libgimp/gimpimagetransform_pdb.h    |   60 +-
 libgimp/gimpimageundo_pdb.c         |  304 ++
 libgimp/gimpimageundo_pdb.h         |   28 +-
 libgimp/gimpitem_pdb.c              |   43 +-
 libgimp/gimpitem_pdb.h              |   94 +-
 libgimp/gimplayer_pdb.c             |  206 ++
 libgimp/gimplayer_pdb.h             |   17 +
 libgimp/gimpselection_pdb.c         |  822 ++++-
 libgimp/gimpselection_pdb.h         |  101 +-
 libgimp/gimptextlayer_pdb.c         |   58 +
 libgimp/gimptextlayer_pdb.h         |  108 +-
 libgimp/gimptexttool_pdb.c          |   79 +
 libgimp/gimptexttool_pdb.h          |   47 +-
 libgimp/gimpvectors_pdb.c           |  317 ++
 libgimp/gimpvectors_pdb.h           |  238 +-
 pdb/lib.pl                          |  826 ++---
 pdb/pdb.pl                          |    3 +-
 40 files changed, 10843 insertions(+), 2091 deletions(-)
---
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index 7780605e00..dad21df6ea 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -94,6 +94,66 @@ _gimp_channel_new (GimpImage     *image,
   return channel_ID;
 }
 
+/**
+ * __gimp_channel_new: (skip)
+ * @image_ID: The image to which to add the channel.
+ * @width: The channel width.
+ * @height: The channel height.
+ * @name: The channel name.
+ * @opacity: The channel opacity.
+ * @color: The channel compositing color.
+ *
+ * Create a new channel.
+ *
+ * This procedure creates a new channel with the specified width,
+ * height, name, opacity and color.
+ * The new channel still needs to be added to the image, as this is not
+ * automatic. Add the new channel with gimp_image_insert_channel().
+ * Other attributes, such as channel visibility, should be set with
+ * explicit procedure calls.
+ * The channel's contents are undefined initially.
+ *
+ * Returns: The newly created channel.
+ **/
+gint32
+__gimp_channel_new (gint32         image_ID,
+                    gint           width,
+                    gint           height,
+                    const gchar   *name,
+                    gdouble        opacity,
+                    const GimpRGB *color)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 channel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_RGB, color,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-channel-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-channel-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return channel_ID;
+}
+
 /**
  * gimp_channel_new_from_component:
  * @image: The image to which to add the channel.
@@ -145,6 +205,57 @@ gimp_channel_new_from_component (GimpImage       *image,
   return channel_ID;
 }
 
+/**
+ * _gimp_channel_new_from_component: (skip)
+ * @image_ID: The image to which to add the channel.
+ * @component: The image component.
+ * @name: The channel name.
+ *
+ * Create a new channel from a color component
+ *
+ * This procedure creates a new channel from a color component.
+ * The new channel still needs to be added to the image, as this is not
+ * automatic. Add the new channel with gimp_image_insert_channel().
+ * Other attributes, such as channel visibility, should be set with
+ * explicit procedure calls.
+ *
+ * Returns: The newly created channel.
+ *
+ * Since: 2.4
+ **/
+gint32
+_gimp_channel_new_from_component (gint32           image_ID,
+                                  GimpChannelType  component,
+                                  const gchar     *name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 channel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-channel-new-from-component",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-channel-new-from-component",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return channel_ID;
+}
+
 /**
  * gimp_channel_copy:
  * @channel_ID: The channel to copy.
diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h
index 4e1cb8318a..1aa515de72 100644
--- a/libgimp/gimpchannel_pdb.h
+++ b/libgimp/gimpchannel_pdb.h
@@ -32,31 +32,42 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-G_GNUC_INTERNAL gint32 _gimp_channel_new               (GimpImage       *image,
-                                                        gint             width,
-                                                        gint             height,
-                                                        const gchar     *name,
-                                                        gdouble          opacity,
-                                                        const GimpRGB   *color);
-gint32                 gimp_channel_new_from_component (GimpImage       *image,
-                                                        GimpChannelType  component,
-                                                        const gchar     *name);
-gint32                 gimp_channel_copy               (gint32           channel_ID);
-gboolean               gimp_channel_combine_masks      (gint32           channel1_ID,
-                                                        gint32           channel2_ID,
-                                                        GimpChannelOps   operation,
-                                                        gint             offx,
-                                                        gint             offy);
-gboolean               gimp_channel_get_show_masked    (gint32           channel_ID);
-gboolean               gimp_channel_set_show_masked    (gint32           channel_ID,
-                                                        gboolean         show_masked);
-gdouble                gimp_channel_get_opacity        (gint32           channel_ID);
-gboolean               gimp_channel_set_opacity        (gint32           channel_ID,
-                                                        gdouble          opacity);
-gboolean               gimp_channel_get_color          (gint32           channel_ID,
-                                                        GimpRGB         *color);
-gboolean               gimp_channel_set_color          (gint32           channel_ID,
-                                                        const GimpRGB   *color);
+G_GNUC_INTERNAL gint32 _gimp_channel_new                (GimpImage       *image,
+                                                         gint             width,
+                                                         gint             height,
+                                                         const gchar     *name,
+                                                         gdouble          opacity,
+                                                         const GimpRGB   *color);
+GIMP_DEPRECATED_FOR(_gimp_channel_new)
+G_GNUC_INTERNAL gint32 __gimp_channel_new               (gint32           image_ID,
+                                                         gint             width,
+                                                         gint             height,
+                                                         const gchar     *name,
+                                                         gdouble          opacity,
+                                                         const GimpRGB   *color);
+gint32                 gimp_channel_new_from_component  (GimpImage       *image,
+                                                         GimpChannelType  component,
+                                                         const gchar     *name);
+GIMP_DEPRECATED_FOR(gimp_channel_new_from_component)
+G_GNUC_INTERNAL gint32 _gimp_channel_new_from_component (gint32           image_ID,
+                                                         GimpChannelType  component,
+                                                         const gchar     *name);
+gint32                 gimp_channel_copy                (gint32           channel_ID);
+gboolean               gimp_channel_combine_masks       (gint32           channel1_ID,
+                                                         gint32           channel2_ID,
+                                                         GimpChannelOps   operation,
+                                                         gint             offx,
+                                                         gint             offy);
+gboolean               gimp_channel_get_show_masked     (gint32           channel_ID);
+gboolean               gimp_channel_set_show_masked     (gint32           channel_ID,
+                                                         gboolean         show_masked);
+gdouble                gimp_channel_get_opacity         (gint32           channel_ID);
+gboolean               gimp_channel_set_opacity         (gint32           channel_ID,
+                                                         gdouble          opacity);
+gboolean               gimp_channel_get_color           (gint32           channel_ID,
+                                                         GimpRGB         *color);
+gboolean               gimp_channel_set_color           (gint32           channel_ID,
+                                                         const GimpRGB   *color);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c
index f89655fead..1f88c8ad1c 100644
--- a/libgimp/gimpdisplay_pdb.c
+++ b/libgimp/gimpdisplay_pdb.c
@@ -120,6 +120,50 @@ gimp_display_new (GimpImage *image)
   return display_ID;
 }
 
+/**
+ * _gimp_display_new: (skip)
+ * @image_ID: The image.
+ *
+ * Create a new display for the specified image.
+ *
+ * Creates a new display for the specified image. If the image already
+ * has a display, another is added. Multiple displays are handled
+ * transparently by GIMP. The newly created display is returned and can
+ * be subsequently destroyed with a call to gimp_display_delete(). This
+ * procedure only makes sense for use with the GIMP UI, and will result
+ * in an execution error if called when GIMP has no UI.
+ *
+ * Returns: The new display.
+ **/
+gint32
+_gimp_display_new (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 display_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-display-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-display-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    display_ID = gimp_value_get_display_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return display_ID;
+}
+
 /**
  * gimp_display_delete:
  * @display_ID: The display to delete.
@@ -289,3 +333,47 @@ gimp_displays_reconnect (GimpImage *old_image,
 
   return success;
 }
+
+/**
+ * _gimp_displays_reconnect: (skip)
+ * @old_image_ID: The old image (must have at least one display).
+ * @new_image_ID: The new image (must not have a display).
+ *
+ * Reconnect displays from one image to another image.
+ *
+ * This procedure connects all displays of the old_image to the
+ * new_image. If the old_image has no display or new_image already has
+ * a display the reconnect is not performed and the procedure returns
+ * without success. You should rarely need to use this function.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_displays_reconnect (gint32 old_image_ID,
+                          gint32 new_image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, old_image_ID,
+                                          GIMP_TYPE_IMAGE_ID, new_image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-displays-reconnect",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-displays-reconnect",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpdisplay_pdb.h b/libgimp/gimpdisplay_pdb.h
index 94a1c00e1d..0feb8edd47 100644
--- a/libgimp/gimpdisplay_pdb.h
+++ b/libgimp/gimpdisplay_pdb.h
@@ -32,13 +32,18 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_display_is_valid          (gint32     display_ID);
-gint32   gimp_display_new               (GimpImage *image);
-gboolean gimp_display_delete            (gint32     display_ID);
-gint     gimp_display_get_window_handle (gint32     display_ID);
-gboolean gimp_displays_flush            (void);
-gboolean gimp_displays_reconnect        (GimpImage *old_image,
-                                         GimpImage *new_image);
+gboolean                 gimp_display_is_valid          (gint32     display_ID);
+gint32                   gimp_display_new               (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_display_new)
+G_GNUC_INTERNAL gint32   _gimp_display_new              (gint32     image_ID);
+gboolean                 gimp_display_delete            (gint32     display_ID);
+gint                     gimp_display_get_window_handle (gint32     display_ID);
+gboolean                 gimp_displays_flush            (void);
+gboolean                 gimp_displays_reconnect        (GimpImage *old_image,
+                                                         GimpImage *new_image);
+GIMP_DEPRECATED_FOR(gimp_displays_reconnect)
+G_GNUC_INTERNAL gboolean _gimp_displays_reconnect       (gint32     old_image_ID,
+                                                         gint32     new_image_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index 7b59d6bb94..4d459445e1 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -172,6 +172,52 @@ gimp_edit_copy_visible (GimpImage *image)
   return non_empty;
 }
 
+/**
+ * _gimp_edit_copy_visible: (skip)
+ * @image_ID: The image to copy from.
+ *
+ * Copy from the projection.
+ *
+ * If there is a selection in the image, then the area specified by the
+ * selection is copied from the projection and placed in an internal
+ * GIMP edit buffer. It can subsequently be retrieved using the
+ * gimp_edit_paste() command. If there is no selection, then the
+ * projection's contents will be stored in the internal GIMP edit
+ * buffer.
+ *
+ * Returns: TRUE if the copy was successful.
+ *
+ * Since: 2.2
+ **/
+gboolean
+_gimp_edit_copy_visible (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-copy-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-copy-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return non_empty;
+}
+
 /**
  * gimp_edit_paste:
  * @drawable_ID: The drawable to paste to.
@@ -263,13 +309,55 @@ gimp_edit_paste_as_new_image (void)
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
 
+/**
+ * _gimp_edit_paste_as_new_image: (skip)
+ *
+ * Paste buffer to a new image.
+ *
+ * This procedure pastes a copy of the internal GIMP edit buffer to a
+ * new image. The GIMP edit buffer will be empty unless a call was
+ * previously made to either gimp_edit_cut() or gimp_edit_copy(). This
+ * procedure returns the new image or -1 if the edit buffer was empty.
+ *
+ * Returns: The new image.
+ *
+ * Since: 2.10
+ **/
+gint32
+_gimp_edit_paste_as_new_image (void)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-paste-as-new-image",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-paste-as-new-image",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
+
 /**
  * gimp_edit_named_cut:
  * @drawable_ID: The drawable to cut from.
@@ -417,6 +505,54 @@ gimp_edit_named_copy_visible (GimpImage   *image,
   return real_name;
 }
 
+/**
+ * _gimp_edit_named_copy_visible: (skip)
+ * @image_ID: The image to copy from.
+ * @buffer_name: The name of the buffer to create.
+ *
+ * Copy from the projection into a named buffer.
+ *
+ * This procedure works like gimp_edit_copy_visible(), but additionally
+ * stores the copied buffer into a named buffer that will stay
+ * available for later pasting, regardless of any intermediate copy or
+ * cut operations.
+ *
+ * Returns: The real name given to the buffer, or NULL if the copy failed.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.4
+ **/
+gchar *
+_gimp_edit_named_copy_visible (gint32       image_ID,
+                               const gchar *buffer_name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *real_name = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-named-copy-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-named-copy-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return real_name;
+}
+
 /**
  * gimp_edit_named_paste:
  * @drawable_ID: The drawable to paste to.
@@ -500,9 +636,51 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
+
+/**
+ * _gimp_edit_named_paste_as_new_image: (skip)
+ * @buffer_name: The name of the buffer to paste.
+ *
+ * Paste named buffer to a new image.
+ *
+ * This procedure works like gimp_edit_paste_as_new_image() but pastes
+ * a named buffer instead of the global buffer.
+ *
+ * Returns: The new image.
+ *
+ * Since: 2.10
+ **/
+gint32
+_gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-named-paste-as-new-image",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-named-paste-as-new-image",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
diff --git a/libgimp/gimpedit_pdb.h b/libgimp/gimpedit_pdb.h
index 4092904f90..5e986004ca 100644
--- a/libgimp/gimpedit_pdb.h
+++ b/libgimp/gimpedit_pdb.h
@@ -32,22 +32,31 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean   gimp_edit_cut                      (gint32       drawable_ID);
-gboolean   gimp_edit_copy                     (gint32       drawable_ID);
-gboolean   gimp_edit_copy_visible             (GimpImage   *image);
-gint32     gimp_edit_paste                    (gint32       drawable_ID,
-                                               gboolean     paste_into);
-GimpImage* gimp_edit_paste_as_new_image       (void);
-gchar*     gimp_edit_named_cut                (gint32       drawable_ID,
-                                               const gchar *buffer_name);
-gchar*     gimp_edit_named_copy               (gint32       drawable_ID,
-                                               const gchar *buffer_name);
-gchar*     gimp_edit_named_copy_visible       (GimpImage   *image,
-                                               const gchar *buffer_name);
-gint32     gimp_edit_named_paste              (gint32       drawable_ID,
-                                               const gchar *buffer_name,
-                                               gboolean     paste_into);
-GimpImage* gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
+gboolean                 gimp_edit_cut                       (gint32       drawable_ID);
+gboolean                 gimp_edit_copy                      (gint32       drawable_ID);
+gboolean                 gimp_edit_copy_visible              (GimpImage   *image);
+GIMP_DEPRECATED_FOR(gimp_edit_copy_visible)
+G_GNUC_INTERNAL gboolean _gimp_edit_copy_visible             (gint32       image_ID);
+gint32                   gimp_edit_paste                     (gint32       drawable_ID,
+                                                              gboolean     paste_into);
+GimpImage*               gimp_edit_paste_as_new_image        (void);
+GIMP_DEPRECATED_FOR(gimp_edit_paste_as_new_image)
+G_GNUC_INTERNAL gint32   _gimp_edit_paste_as_new_image       (void);
+gchar*                   gimp_edit_named_cut                 (gint32       drawable_ID,
+                                                              const gchar *buffer_name);
+gchar*                   gimp_edit_named_copy                (gint32       drawable_ID,
+                                                              const gchar *buffer_name);
+gchar*                   gimp_edit_named_copy_visible        (GimpImage   *image,
+                                                              const gchar *buffer_name);
+GIMP_DEPRECATED_FOR(gimp_edit_named_copy_visible)
+G_GNUC_INTERNAL gchar*   _gimp_edit_named_copy_visible       (gint32       image_ID,
+                                                              const gchar *buffer_name);
+gint32                   gimp_edit_named_paste               (gint32       drawable_ID,
+                                                              const gchar *buffer_name,
+                                                              gboolean     paste_into);
+GimpImage*               gimp_edit_named_paste_as_new_image  (const gchar *buffer_name);
+GIMP_DEPRECATED_FOR(gimp_edit_named_paste_as_new_image)
+G_GNUC_INTERNAL gint32   _gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index f6dc0ca92f..794da05541 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -78,13 +78,64 @@ gimp_file_load (GimpRunMode  run_mode,
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
 
+/**
+ * _gimp_file_load: (skip)
+ * @run_mode: The run mode.
+ * @filename: The name of the file to load.
+ * @raw_filename: The name as entered by the user.
+ *
+ * Loads an image file by invoking the right load handler.
+ *
+ * This procedure invokes the correct file load handler using magic if
+ * possible, and falling back on the file's extension and/or prefix if
+ * not. The name of the file to load is typically a full pathname, and
+ * the name entered is what the user actually typed before prepending a
+ * directory path. The reason for this is that if the user types
+ * https://www.gimp.org/foo.png he wants to fetch a URL, and the full
+ * pathname will not look like a URL.
+ *
+ * Returns: The output image.
+ **/
+gint32
+_gimp_file_load (GimpRunMode  run_mode,
+                 const gchar *filename,
+                 const gchar *raw_filename)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_STRING, raw_filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-file-load",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-file-load",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
+
 /**
  * gimp_file_load_layer:
  * @run_mode: The run mode.
@@ -135,6 +186,56 @@ gimp_file_load_layer (GimpRunMode  run_mode,
   return layer_ID;
 }
 
+/**
+ * _gimp_file_load_layer: (skip)
+ * @run_mode: The run mode.
+ * @image_ID: Destination image.
+ * @filename: The name of the file to load.
+ *
+ * Loads an image file as a layer for an existing image.
+ *
+ * This procedure behaves like the file-load procedure but opens the
+ * specified image as a layer for an existing image. The returned layer
+ * needs to be added to the existing image with
+ * gimp_image_insert_layer().
+ *
+ * Returns: The layer created when loading the image file.
+ *
+ * Since: 2.4
+ **/
+gint32
+_gimp_file_load_layer (GimpRunMode  run_mode,
+                       gint32       image_ID,
+                       const gchar *filename)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-file-load-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-file-load-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
 /**
  * gimp_file_load_layers:
  * @run_mode: The run mode.
@@ -194,6 +295,64 @@ gimp_file_load_layers (GimpRunMode  run_mode,
   return layer_ids;
 }
 
+/**
+ * _gimp_file_load_layers: (skip)
+ * @run_mode: The run mode.
+ * @image_ID: Destination image.
+ * @filename: The name of the file to load.
+ * @num_layers: (out): The number of loaded layers.
+ *
+ * Loads an image file as layers for an existing image.
+ *
+ * This procedure behaves like the file-load procedure but opens the
+ * specified image as layers for an existing image. The returned layers
+ * needs to be added to the existing image with
+ * gimp_image_insert_layer().
+ *
+ * Returns: (array length=num_layers): The list of loaded layers.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.4
+ **/
+gint *
+_gimp_file_load_layers (GimpRunMode  run_mode,
+                        gint32       image_ID,
+                        const gchar *filename,
+                        gint        *num_layers)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *layer_ids = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-file-load-layers",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-file-load-layers",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_layers = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ids;
+}
+
 /**
  * gimp_file_save:
  * @run_mode: The run mode.
@@ -250,6 +409,62 @@ gimp_file_save (GimpRunMode  run_mode,
   return success;
 }
 
+/**
+ * _gimp_file_save: (skip)
+ * @run_mode: The run mode.
+ * @image_ID: Input image.
+ * @drawable_ID: Drawable to save.
+ * @filename: The name of the file to save the image in.
+ * @raw_filename: The name as entered by the user.
+ *
+ * Saves a file by extension.
+ *
+ * This procedure invokes the correct file save handler according to
+ * the file's extension and/or prefix. The name of the file to save is
+ * typically a full pathname, and the name entered is what the user
+ * actually typed before prepending a directory path. The reason for
+ * this is that if the user types https://www.gimp.org/foo.png she
+ * wants to fetch a URL, and the full pathname will not look like a
+ * URL.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_file_save (GimpRunMode  run_mode,
+                 gint32       image_ID,
+                 gint32       drawable_ID,
+                 const gchar *filename,
+                 const gchar *raw_filename)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_STRING, raw_filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-file-save",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-file-save",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_file_save_thumbnail:
  * @image: The image.
@@ -296,6 +511,52 @@ gimp_file_save_thumbnail (GimpImage   *image,
   return success;
 }
 
+/**
+ * _gimp_file_save_thumbnail: (skip)
+ * @image_ID: The image.
+ * @filename: The name of the file the thumbnail belongs to.
+ *
+ * Saves a thumbnail for the given image
+ *
+ * This procedure saves a thumbnail for the given image according to
+ * the Free Desktop Thumbnail Managing Standard. The thumbnail is saved
+ * so that it belongs to the file with the given filename. This means
+ * you have to save the image under this name first, otherwise this
+ * procedure will fail. This procedure may become useful if you want to
+ * explicitly save a thumbnail with a file.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_file_save_thumbnail (gint32       image_ID,
+                           const gchar *filename)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-file-save-thumbnail",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-file-save-thumbnail",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * _gimp_register_magic_load_handler:
  * @procedure_name: The name of the procedure to be used for loading.
diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h
index 69b11dacae..c0c0ec1a53 100644
--- a/libgimp/gimpfileops_pdb.h
+++ b/libgimp/gimpfileops_pdb.h
@@ -35,20 +35,42 @@ G_BEGIN_DECLS
 GimpImage*               gimp_file_load                       (GimpRunMode  run_mode,
                                                                const gchar *filename,
                                                                const gchar *raw_filename);
+GIMP_DEPRECATED_FOR(gimp_file_load)
+G_GNUC_INTERNAL gint32   _gimp_file_load                      (GimpRunMode  run_mode,
+                                                               const gchar *filename,
+                                                               const gchar *raw_filename);
 gint32                   gimp_file_load_layer                 (GimpRunMode  run_mode,
                                                                GimpImage   *image,
                                                                const gchar *filename);
+GIMP_DEPRECATED_FOR(gimp_file_load_layer)
+G_GNUC_INTERNAL gint32   _gimp_file_load_layer                (GimpRunMode  run_mode,
+                                                               gint32       image_ID,
+                                                               const gchar *filename);
 gint*                    gimp_file_load_layers                (GimpRunMode  run_mode,
                                                                GimpImage   *image,
                                                                const gchar *filename,
                                                                gint        *num_layers);
+GIMP_DEPRECATED_FOR(gimp_file_load_layers)
+G_GNUC_INTERNAL gint*    _gimp_file_load_layers               (GimpRunMode  run_mode,
+                                                               gint32       image_ID,
+                                                               const gchar *filename,
+                                                               gint        *num_layers);
 gboolean                 gimp_file_save                       (GimpRunMode  run_mode,
                                                                GimpImage   *image,
                                                                gint32       drawable_ID,
                                                                const gchar *filename,
                                                                const gchar *raw_filename);
+GIMP_DEPRECATED_FOR(gimp_file_save)
+G_GNUC_INTERNAL gboolean _gimp_file_save                      (GimpRunMode  run_mode,
+                                                               gint32       image_ID,
+                                                               gint32       drawable_ID,
+                                                               const gchar *filename,
+                                                               const gchar *raw_filename);
 gboolean                 gimp_file_save_thumbnail             (GimpImage   *image,
                                                                const gchar *filename);
+GIMP_DEPRECATED_FOR(gimp_file_save_thumbnail)
+G_GNUC_INTERNAL gboolean _gimp_file_save_thumbnail            (gint32       image_ID,
+                                                               const gchar *filename);
 G_GNUC_INTERNAL gboolean _gimp_register_magic_load_handler    (const gchar *procedure_name,
                                                                const gchar *extensions,
                                                                const gchar *prefixes,
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 3b9dc85723..b3970d9e77 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -77,6 +77,48 @@ gimp_image_is_valid (GimpImage *image)
   return valid;
 }
 
+/**
+ * _gimp_image_is_valid: (skip)
+ * @image_ID: The image to check.
+ *
+ * Returns TRUE if the image is valid.
+ *
+ * This procedure checks if the given image is valid and refers to an
+ * existing image.
+ *
+ * Returns: Whether the image is valid.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_is_valid (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean valid = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-is-valid",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-is-valid",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    valid = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return valid;
+}
+
 /**
  * gimp_image_list:
  * @num_images: (out): The number of images currently open.
@@ -169,13 +211,67 @@ gimp_image_new (gint              width,
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
 
+/**
+ * _gimp_image_new: (skip)
+ * @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 newly created image.
+ **/
+gint32
+_gimp_image_new (gint              width,
+                 gint              height,
+                 GimpImageBaseType type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
+
 /**
  * gimp_image_new_with_precision:
  * @width: The width of the image.
@@ -223,13 +319,67 @@ gimp_image_new_with_precision (gint              width,
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
 
+/**
+ * _gimp_image_new_with_precision: (skip)
+ * @width: The width of the image.
+ * @height: The height of the image.
+ * @type: The type of image.
+ * @precision: The precision.
+ *
+ * Creates a new image with the specified width, height, type and
+ * precision.
+ *
+ * Creates a new image, undisplayed with the specified extents, type
+ * and precision. Indexed images can only be created at
+ * GIMP_PRECISION_U8_NON_LINEAR precision. See gimp_image_new() for
+ * further details.
+ *
+ * Returns: The newly created image.
+ *
+ * Since: 2.10
+ **/
+gint32
+_gimp_image_new_with_precision (gint              width,
+                                gint              height,
+                                GimpImageBaseType type,
+                                GimpPrecision     precision)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
+                                          GIMP_TYPE_PRECISION, precision,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-new-with-precision",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-new-with-precision",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
+
 /**
  * gimp_image_duplicate:
  * @image: The image.
@@ -263,13 +413,53 @@ gimp_image_duplicate (GimpImage *image)
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    new_image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    new_image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return new_image;
 }
 
+/**
+ * _gimp_image_duplicate: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 new_image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-duplicate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-duplicate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    new_image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return new_image_ID;
+}
+
 /**
  * gimp_image_delete:
  * @image: The image.
@@ -313,6 +503,49 @@ gimp_image_delete (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_delete: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-delete",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-delete",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_base_type:
  * @image: The image.
@@ -353,6 +586,46 @@ gimp_image_base_type (GimpImage *image)
   return base_type;
 }
 
+/**
+ * _gimp_image_base_type: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpImageBaseType base_type = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-base-type",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-base-type",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    base_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return base_type;
+}
+
 /**
  * gimp_image_get_precision:
  * @image: The image.
@@ -395,40 +668,122 @@ gimp_image_get_precision (GimpImage *image)
 }
 
 /**
- * gimp_image_get_default_new_layer_mode:
- * @image: The image.
+ * _gimp_image_get_precision: (skip)
+ * @image_ID: The image.
  *
- * Get the default mode for newly created layers of this image.
+ * Get the precision of the image.
  *
- * Returns the default mode for newly created layers of this image.
+ * This procedure returns the image's precision.
  *
- * Returns: The layer mode.
+ * Returns: The image's precision.
  *
  * Since: 2.10
  **/
-GimpLayerMode
-gimp_image_get_default_new_layer_mode (GimpImage *image)
+GimpPrecision
+_gimp_image_get_precision (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpLayerMode mode = 0;
+  GimpPrecision precision = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-default-new-layer-mode",
+                                                "gimp-image-get-precision",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-default-new-layer-mode",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-precision",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+    precision = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return precision;
+}
+
+/**
+ * gimp_image_get_default_new_layer_mode:
+ * @image: The image.
+ *
+ * Get the default mode for newly created layers of this image.
+ *
+ * Returns the default mode for newly created layers of this image.
+ *
+ * Returns: The layer mode.
+ *
+ * Since: 2.10
+ **/
+GimpLayerMode
+gimp_image_get_default_new_layer_mode (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayerMode mode = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-default-new-layer-mode",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-default-new-layer-mode",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return mode;
+}
+
+/**
+ * _gimp_image_get_default_new_layer_mode: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayerMode mode = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-default-new-layer-mode",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-default-new-layer-mode",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
@@ -475,6 +830,46 @@ gimp_image_width (GimpImage *image)
   return width;
 }
 
+/**
+ * _gimp_image_width: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint width = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-width",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-width",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return width;
+}
+
 /**
  * gimp_image_height:
  * @image: The image.
@@ -515,6 +910,46 @@ gimp_image_height (GimpImage *image)
   return height;
 }
 
+/**
+ * _gimp_image_height: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint height = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-height",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-height",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    height = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return height;
+}
+
 /**
  * gimp_image_get_layers:
  * @image: The image.
@@ -564,6 +999,55 @@ gimp_image_get_layers (GimpImage *image,
   return layer_ids;
 }
 
+/**
+ * _gimp_image_get_layers: (skip)
+ * @image_ID: The image.
+ * @num_layers: (out): The number of layers contained in the image.
+ *
+ * Returns the list of layers contained in the specified image.
+ *
+ * This procedure returns the list of layers contained in the specified
+ * image. The order of layers is from topmost to bottommost.
+ *
+ * Returns: (array length=num_layers):
+ *          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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *layer_ids = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-layers",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-layers",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_layers = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ids;
+}
+
 /**
  * gimp_image_get_channels:
  * @image: The image.
@@ -616,6 +1100,58 @@ gimp_image_get_channels (GimpImage *image,
   return channel_ids;
 }
 
+/**
+ * _gimp_image_get_channels: (skip)
+ * @image_ID: The image.
+ * @num_channels: (out): The number of channels contained in the image.
+ *
+ * Returns the list of channels contained in the specified image.
+ *
+ * This procedure returns the list of channels contained in the
+ * specified image. This does not include the selection mask, or layer
+ * masks. The order is from topmost to bottommost. Note that
+ * \"channels\" are custom channels and do not include the image's
+ * color components.
+ *
+ * Returns: (array length=num_channels):
+ *          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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *channel_ids = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-channels",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-channels",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_channels = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_channels = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      channel_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return channel_ids;
+}
+
 /**
  * gimp_image_get_vectors:
  * @image: The image.
@@ -668,22 +1204,73 @@ gimp_image_get_vectors (GimpImage *image,
 }
 
 /**
- * gimp_image_get_active_drawable:
- * @image: The image.
+ * _gimp_image_get_vectors: (skip)
+ * @image_ID: The image.
+ * @num_vectors: (out): The number of vectors contained in the image.
  *
- * Get the image's active drawable
+ * Returns the list of vectors contained in the specified image.
  *
- * 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.
+ * This procedure returns the list of vectors contained in the
+ * specified image.
  *
- * Returns: The active drawable.
- **/
-gint32
-gimp_image_get_active_drawable (GimpImage *image)
+ * Returns: (array length=num_vectors):
+ *          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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *vector_ids = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_vectors = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      vector_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return vector_ids;
+}
+
+/**
+ * gimp_image_get_active_drawable:
+ * @image: The image.
+ *
+ * Get the image's active drawable
+ *
+ * This procedure returns the ID of the image's active drawable. This
+ * can be either a layer, a channel, or a layer mask. The active
+ * drawable is specified by the active image channel. If that is -1,
+ * then by the active image layer. If the active image layer has a
+ * layer mask and the layer mask is in edit mode, then the layer mask
+ * is the active drawable.
+ *
+ * Returns: The active drawable.
+ **/
+gint32
+gimp_image_get_active_drawable (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -711,6 +1298,50 @@ gimp_image_get_active_drawable (GimpImage *image)
   return drawable_ID;
 }
 
+/**
+ * _gimp_image_get_active_drawable: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 drawable_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-drawable",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-drawable",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return drawable_ID;
+}
+
 /**
  * gimp_image_unset_active_channel:
  * @image: The image.
@@ -752,6 +1383,47 @@ gimp_image_unset_active_channel (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_unset_active_channel: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-unset-active-channel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-unset-active-channel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_get_floating_sel:
  * @image: The image.
@@ -792,6 +1464,46 @@ gimp_image_get_floating_sel (GimpImage *image)
   return floating_sel_ID;
 }
 
+/**
+ * _gimp_image_get_floating_sel: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 floating_sel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-floating-sel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-floating-sel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    floating_sel_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return floating_sel_ID;
+}
+
 /**
  * gimp_image_floating_sel_attached_to:
  * @image: The image.
@@ -833,6 +1545,47 @@ gimp_image_floating_sel_attached_to (GimpImage *image)
   return drawable_ID;
 }
 
+/**
+ * _gimp_image_floating_sel_attached_to: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 drawable_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-floating-sel-attached-to",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-floating-sel-attached-to",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return drawable_ID;
+}
+
 /**
  * gimp_image_pick_color:
  * @image: The image.
@@ -905,47 +1658,167 @@ gimp_image_pick_color (GimpImage *image,
 }
 
 /**
- * gimp_image_pick_correlate_layer:
- * @image: The image.
- * @x: The x coordinate for the pick.
- * @y: The y coordinate for the pick.
+ * _gimp_image_pick_color: (skip)
+ * @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: (out caller-allocates): The return color.
  *
- * Find the layer visible at the specified coordinates.
+ * Determine the color at the given drawable 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.
+ * 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: The layer found at the specified coordinates.
+ * Returns: TRUE on success.
  **/
-gint32
-gimp_image_pick_correlate_layer (GimpImage *image,
-                                 gint       x,
-                                 gint       y)
+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)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_INT, x,
-                                          G_TYPE_INT, y,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_BOOLEAN, sample_merged,
+                                          G_TYPE_BOOLEAN, sample_average,
+                                          G_TYPE_DOUBLE, average_radius,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-pick-correlate-layer",
+                                                "gimp-image-pick-color",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-pick-correlate-layer",
+    return_vals = gimp_run_procedure_array ("gimp-image-pick-color",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_pick_correlate_layer:
+ * @image: The image.
+ * @x: The x coordinate for the pick.
+ * @y: The y coordinate for the pick.
+ *
+ * Find the layer visible at the specified coordinates.
+ *
+ * This procedure finds the layer which is visible at the specified
+ * coordinates. Layers which do not qualify are those whose extents do
+ * not pass within the specified coordinates, or which are transparent
+ * at the specified coordinates. This procedure will return -1 if no
+ * layer is found.
+ *
+ * Returns: The layer found at the specified coordinates.
+ **/
+gint32
+gimp_image_pick_correlate_layer (GimpImage *image,
+                                 gint       x,
+                                 gint       y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_INT, x,
+                                          G_TYPE_INT, y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-pick-correlate-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-pick-correlate-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
+/**
+ * _gimp_image_pick_correlate_layer: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, x,
+                                          G_TYPE_INT, y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-pick-correlate-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-pick-correlate-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
     layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
@@ -1011,23 +1884,33 @@ gimp_image_insert_layer (GimpImage *image,
 }
 
 /**
- * gimp_image_remove_layer:
- * @image: The image.
+ * _gimp_image_insert_layer: (skip)
+ * @image_ID: The image.
  * @layer_ID: The layer.
+ * @parent_ID: The parent layer.
+ * @position: The layer position.
  *
- * Remove the specified layer from the image.
+ * Add the specified layer to 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.
+ * 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_remove_layer (GimpImage *image,
-                         gint32     layer_ID)
+_gimp_image_insert_layer (gint32 image_ID,
+                          gint32 layer_ID,
+                          gint32 parent_ID,
+                          gint   position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1035,16 +1918,18 @@ gimp_image_remove_layer (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, parent_ID,
+                                          G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-remove-layer",
+                                                "gimp-image-insert-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-remove-layer",
+    return_vals = gimp_run_procedure_array ("gimp-image-insert-layer",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1056,25 +1941,23 @@ gimp_image_remove_layer (GimpImage *image,
 }
 
 /**
- * gimp_image_freeze_layers:
+ * gimp_image_remove_layer:
  * @image: The image.
+ * @layer_ID: The layer.
  *
- * 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.
+ * Remove the specified layer from the image.
  *
- * Each call to gimp_image_freeze_layers() should be matched by a
- * corresponding call to gimp_image_thaw_layers(), undoing its effects.
+ * 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.
- *
- * Since: 2.10.2
  **/
 gboolean
-gimp_image_freeze_layers (GimpImage *image)
+gimp_image_remove_layer (GimpImage *image,
+                         gint32     layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1083,14 +1966,15 @@ gimp_image_freeze_layers (GimpImage *image)
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-freeze-layers",
+                                                "gimp-image-remove-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-freeze-layers",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-layer",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1102,23 +1986,23 @@ gimp_image_freeze_layers (GimpImage *image)
 }
 
 /**
- * gimp_image_thaw_layers:
- * @image: The image.
- *
- * Thaw the image's layer list.
+ * _gimp_image_remove_layer: (skip)
+ * @image_ID: The image.
+ * @layer_ID: The layer.
  *
- * This procedure thaws the layer list of the image, re-enabling
- * updates to the Layers dialog.
+ * Remove the specified layer from the image.
  *
- * This procedure should match a corresponding call to
- * gimp_image_freeze_layers().
+ * 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.
- *
- * Since: 2.10.2
  **/
 gboolean
-gimp_image_thaw_layers (GimpImage *image)
+_gimp_image_remove_layer (gint32 image_ID,
+                          gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1126,15 +2010,16 @@ gimp_image_thaw_layers (GimpImage *image)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-thaw-layers",
+                                                "gimp-image-remove-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-thaw-layers",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-layer",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1146,28 +2031,25 @@ gimp_image_thaw_layers (GimpImage *image)
 }
 
 /**
- * gimp_image_insert_channel:
+ * gimp_image_freeze_layers:
  * @image: The image.
- * @channel_ID: The channel.
- * @parent_ID: The parent channel.
- * @position: The channel position.
  *
- * Add the specified channel to the image.
+ * Freeze the image's layer list.
  *
- * 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.
+ * 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_insert_channel (GimpImage *image,
-                           gint32     channel_ID,
-                           gint32     parent_ID,
-                           gint       position)
+gimp_image_freeze_layers (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1176,17 +2058,14 @@ gimp_image_insert_channel (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
-                                          GIMP_TYPE_CHANNEL_ID, parent_ID,
-                                          G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-insert-channel",
+                                                "gimp-image-freeze-layers",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-insert-channel",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-layers",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1198,20 +2077,25 @@ gimp_image_insert_channel (GimpImage *image,
 }
 
 /**
- * gimp_image_remove_channel:
- * @image: The image.
- * @channel_ID: The channel.
+ * _gimp_image_freeze_layers: (skip)
+ * @image_ID: The image.
  *
- * Remove the specified channel from the image.
+ * Freeze the image's layer list.
  *
- * This procedure removes the specified channel from the image. If the
- * channel doesn't exist, an error is returned.
+ * 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_remove_channel (GimpImage *image,
-                           gint32     channel_ID)
+_gimp_image_freeze_layers (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1219,16 +2103,15 @@ gimp_image_remove_channel (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-remove-channel",
+                                                "gimp-image-freeze-layers",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-remove-channel",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-layers",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1240,26 +2123,23 @@ gimp_image_remove_channel (GimpImage *image,
 }
 
 /**
- * gimp_image_freeze_channels:
+ * gimp_image_thaw_layers:
  * @image: The image.
  *
- * Freeze the image's channel list.
+ * Thaw the image's layer 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.
+ * This procedure thaws the layer list of the image, re-enabling
+ * updates to the Layers dialog.
  *
- * Each call to gimp_image_freeze_channels() should be matched by a
- * corresponding call to gimp_image_thaw_channels(), undoing its
- * effects.
+ * This procedure should match a corresponding call to
+ * gimp_image_freeze_layers().
  *
  * Returns: TRUE on success.
  *
  * Since: 2.10.2
  **/
 gboolean
-gimp_image_freeze_channels (GimpImage *image)
+gimp_image_thaw_layers (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1272,10 +2152,10 @@ gimp_image_freeze_channels (GimpImage *image)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-freeze-channels",
+                                                "gimp-image-thaw-layers",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-freeze-channels",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-layers",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1287,23 +2167,23 @@ gimp_image_freeze_channels (GimpImage *image)
 }
 
 /**
- * gimp_image_thaw_channels:
- * @image: The image.
+ * _gimp_image_thaw_layers: (skip)
+ * @image_ID: The image.
  *
- * Thaw the image's channel list.
+ * Thaw the image's layer list.
  *
- * This procedure thaws the channel list of the image, re-enabling
- * updates to the Channels dialog.
+ * 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_channels().
+ * gimp_image_freeze_layers().
  *
  * Returns: TRUE on success.
  *
  * Since: 2.10.2
  **/
 gboolean
-gimp_image_thaw_channels (GimpImage *image)
+_gimp_image_thaw_layers (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1311,15 +2191,15 @@ gimp_image_thaw_channels (GimpImage *image)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-thaw-channels",
+                                                "gimp-image-thaw-layers",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-thaw-channels",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-layers",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1331,26 +2211,26 @@ gimp_image_thaw_channels (GimpImage *image)
 }
 
 /**
- * gimp_image_insert_vectors:
+ * gimp_image_insert_channel:
  * @image: The image.
- * @vectors_ID: The vectors.
- * @parent_ID: The parent vectors.
- * @position: The vectors position.
+ * @channel_ID: The channel.
+ * @parent_ID: The parent channel.
+ * @position: The channel position.
  *
- * Add the specified vectors to the image.
+ * Add the specified channel to the image.
  *
- * This procedure adds the specified vectors to the image at the given
- * position. Since vectors groups are not currently supported, the
+ * 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 vectors inside the stack, starting from the top
+ * the location of the channel 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.
+ * channel is inserted above the active channel.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_image_insert_vectors (GimpImage *image,
-                           gint32     vectors_ID,
+gimp_image_insert_channel (GimpImage *image,
+                           gint32     channel_ID,
                            gint32     parent_ID,
                            gint       position)
 {
@@ -1361,17 +2241,17 @@ gimp_image_insert_vectors (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
-                                          GIMP_TYPE_VECTORS_ID, parent_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          GIMP_TYPE_CHANNEL_ID, parent_ID,
                                           G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-insert-vectors",
+                                                "gimp-image-insert-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-insert-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-insert-channel",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1383,22 +2263,28 @@ gimp_image_insert_vectors (GimpImage *image,
 }
 
 /**
- * gimp_image_remove_vectors:
- * @image: The image.
- * @vectors_ID: The vectors object.
+ * _gimp_image_insert_channel: (skip)
+ * @image_ID: The image.
+ * @channel_ID: The channel.
+ * @parent_ID: The parent channel.
+ * @position: The channel position.
  *
- * Remove the specified path from the image.
+ * Add the specified channel to the image.
  *
- * This procedure removes the specified path from the image. If the
- * path doesn't exist, an error is returned.
+ * 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.
- *
- * Since: 2.4
  **/
 gboolean
-gimp_image_remove_vectors (GimpImage *image,
-                           gint32     vectors_ID)
+_gimp_image_insert_channel (gint32 image_ID,
+                            gint32 channel_ID,
+                            gint32 parent_ID,
+                            gint   position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1406,16 +2292,18 @@ gimp_image_remove_vectors (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          GIMP_TYPE_CHANNEL_ID, parent_ID,
+                                          G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-remove-vectors",
+                                                "gimp-image-insert-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-remove-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-insert-channel",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1427,26 +2315,20 @@ gimp_image_remove_vectors (GimpImage *image,
 }
 
 /**
- * gimp_image_freeze_vectors:
+ * gimp_image_remove_channel:
  * @image: The image.
+ * @channel_ID: The channel.
  *
- * 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.
+ * Remove the specified channel from the image.
  *
- * Each call to gimp_image_freeze_vectors() should be matched by a
- * corresponding call to gimp_image_thaw_vectors(), undoing its
- * effects.
+ * This procedure removes the specified channel from the image. If the
+ * channel doesn't exist, an error is returned.
  *
  * Returns: TRUE on success.
- *
- * Since: 2.10.2
  **/
 gboolean
-gimp_image_freeze_vectors (GimpImage *image)
+gimp_image_remove_channel (GimpImage *image,
+                           gint32     channel_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1455,14 +2337,15 @@ gimp_image_freeze_vectors (GimpImage *image)
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-freeze-vectors",
+                                                "gimp-image-remove-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-freeze-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-channel",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1474,23 +2357,20 @@ gimp_image_freeze_vectors (GimpImage *image)
 }
 
 /**
- * gimp_image_thaw_vectors:
- * @image: The image.
- *
- * Thaw the image's vectors list.
+ * _gimp_image_remove_channel: (skip)
+ * @image_ID: The image.
+ * @channel_ID: The channel.
  *
- * This procedure thaws the vectors list of the image, re-enabling
- * updates to the Paths dialog.
+ * Remove the specified channel from the image.
  *
- * This procedure should match a corresponding call to
- * gimp_image_freeze_vectors().
+ * This procedure removes the specified channel from the image. If the
+ * channel doesn't exist, an error is returned.
  *
  * Returns: TRUE on success.
- *
- * Since: 2.10.2
  **/
 gboolean
-gimp_image_thaw_vectors (GimpImage *image)
+_gimp_image_remove_channel (gint32 image_ID,
+                            gint32 channel_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1498,15 +2378,16 @@ gimp_image_thaw_vectors (GimpImage *image)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-thaw-vectors",
+                                                "gimp-image-remove-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-thaw-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-channel",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1518,69 +2399,73 @@ gimp_image_thaw_vectors (GimpImage *image)
 }
 
 /**
- * gimp_image_get_item_position:
+ * gimp_image_freeze_channels:
  * @image: The image.
- * @item_ID: The item.
  *
- * Returns the position of the item in its level of its item tree.
+ * Freeze the image's channel list.
  *
- * 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.
+ * 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.
  *
- * Returns: The position of the item in its level in the item tree.
+ * Each call to gimp_image_freeze_channels() should be matched by a
+ * corresponding call to gimp_image_thaw_channels(), undoing its
+ * effects.
  *
- * Since: 2.8
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10.2
  **/
-gint
-gimp_image_get_item_position (GimpImage *image,
-                              gint32     item_ID)
+gboolean
+gimp_image_freeze_channels (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint position = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-item-position",
+                                                "gimp-image-freeze-channels",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-item-position",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-channels",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    position = g_value_get_int (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return position;
+  return success;
 }
 
 /**
- * gimp_image_raise_item:
- * @image: The image.
- * @item_ID: The item to raise.
+ * _gimp_image_freeze_channels: (skip)
+ * @image_ID: The image.
  *
- * Raise the specified item in its level in its item tree
+ * Freeze the image's channel list.
  *
- * This procedure raises the specified item one step in the item tree.
- * The procedure call will fail if there is no item above it.
+ * 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.8
+ * Since: 2.10.2
  **/
 gboolean
-gimp_image_raise_item (GimpImage *image,
-                       gint32     item_ID)
+_gimp_image_freeze_channels (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1588,16 +2473,15 @@ gimp_image_raise_item (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-raise-item",
+                                                "gimp-image-freeze-channels",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-raise-item",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-channels",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1609,22 +2493,23 @@ gimp_image_raise_item (GimpImage *image,
 }
 
 /**
- * gimp_image_lower_item:
+ * gimp_image_thaw_channels:
  * @image: The image.
- * @item_ID: The item to lower.
  *
- * Lower the specified item in its level in its item tree
+ * Thaw the image's channel list.
  *
- * This procedure lowers the specified item one step in the item tree.
- * The procedure call will fail if there is no item below it.
+ * 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.8
+ * Since: 2.10.2
  **/
 gboolean
-gimp_image_lower_item (GimpImage *image,
-                       gint32     item_ID)
+gimp_image_thaw_channels (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1633,15 +2518,14 @@ gimp_image_lower_item (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-lower-item",
+                                                "gimp-image-thaw-channels",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-lower-item",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-channels",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1653,22 +2537,23 @@ gimp_image_lower_item (GimpImage *image,
 }
 
 /**
- * gimp_image_raise_item_to_top:
- * @image: The image.
- * @item_ID: The item to raise to top.
+ * _gimp_image_thaw_channels: (skip)
+ * @image_ID: The image.
  *
- * Raise the specified item to the top of its level in its item tree
+ * Thaw the image's channel list.
  *
- * 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.
+ * 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.8
+ * Since: 2.10.2
  **/
 gboolean
-gimp_image_raise_item_to_top (GimpImage *image,
-                              gint32     item_ID)
+_gimp_image_thaw_channels (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1676,16 +2561,15 @@ gimp_image_raise_item_to_top (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-raise-item-to-top",
+                                                "gimp-image-thaw-channels",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-raise-item-to-top",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-channels",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1697,23 +2581,28 @@ gimp_image_raise_item_to_top (GimpImage *image,
 }
 
 /**
- * gimp_image_lower_item_to_bottom:
+ * gimp_image_insert_vectors:
  * @image: The image.
- * @item_ID: The item to lower to bottom.
+ * @vectors_ID: The vectors.
+ * @parent_ID: The parent vectors.
+ * @position: The vectors position.
  *
- * Lower the specified item to the bottom of its level in its item tree
+ * Add the specified vectors to the image.
  *
- * 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.
+ * 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.
- *
- * Since: 2.8
  **/
 gboolean
-gimp_image_lower_item_to_bottom (GimpImage *image,
-                                 gint32     item_ID)
+gimp_image_insert_vectors (GimpImage *image,
+                           gint32     vectors_ID,
+                           gint32     parent_ID,
+                           gint       position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1722,15 +2611,17 @@ gimp_image_lower_item_to_bottom (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_NONE);
-
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_VECTORS_ID, parent_ID,
+                                          G_TYPE_INT, position,
+                                          G_TYPE_NONE);
+
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-lower-item-to-bottom",
+                                                "gimp-image-insert-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-lower-item-to-bottom",
+    return_vals = gimp_run_procedure_array ("gimp-image-insert-vectors",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1742,25 +2633,28 @@ gimp_image_lower_item_to_bottom (GimpImage *image,
 }
 
 /**
- * gimp_image_reorder_item:
- * @image: The image.
- * @item_ID: The item to reorder.
- * @parent_ID: The new parent item.
- * @position: The new position of the item.
+ * _gimp_image_insert_vectors: (skip)
+ * @image_ID: The image.
+ * @vectors_ID: The vectors.
+ * @parent_ID: The parent vectors.
+ * @position: The vectors position.
  *
- * Reorder the specified item within its item tree
+ * Add the specified vectors to the image.
  *
- * This procedure reorders the specified item within its item tree.
+ * 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.
- *
- * Since: 2.8
  **/
 gboolean
-gimp_image_reorder_item (GimpImage *image,
-                         gint32     item_ID,
-                         gint32     parent_ID,
-                         gint       position)
+_gimp_image_insert_vectors (gint32 image_ID,
+                            gint32 vectors_ID,
+                            gint32 parent_ID,
+                            gint   position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1768,18 +2662,18 @@ gimp_image_reorder_item (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          GIMP_TYPE_ITEM_ID, parent_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_VECTORS_ID, parent_ID,
                                           G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-reorder-item",
+                                                "gimp-image-insert-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-reorder-item",
+    return_vals = gimp_run_procedure_array ("gimp-image-insert-vectors",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1791,217 +2685,205 @@ gimp_image_reorder_item (GimpImage *image,
 }
 
 /**
- * gimp_image_flatten:
+ * gimp_image_remove_vectors:
  * @image: The image.
+ * @vectors_ID: The vectors object.
  *
- * Flatten all visible layers into a single layer. Discard all
- * invisible layers.
+ * Remove the specified path from the image.
  *
- * 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.
+ * This procedure removes the specified path from the image. If the
+ * path doesn't exist, an error is returned.
  *
- * Returns: The resulting layer.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
  **/
-gint32
-gimp_image_flatten (GimpImage *image)
+gboolean
+gimp_image_remove_vectors (GimpImage *image,
+                           gint32     vectors_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-flatten",
+                                                "gimp-image-remove-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-flatten",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-vectors",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return success;
 }
 
 /**
- * gimp_image_merge_visible_layers:
- * @image: The image.
- * @merge_type: The type of merge.
+ * _gimp_image_remove_vectors: (skip)
+ * @image_ID: The image.
+ * @vectors_ID: The vectors object.
  *
- * Merge the visible image layers into one.
+ * Remove the specified path from the image.
  *
- * 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.
+ * This procedure removes the specified path from the image. If the
+ * path doesn't exist, an error is returned.
  *
- * Returns: The resulting layer.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
  **/
-gint32
-gimp_image_merge_visible_layers (GimpImage     *image,
-                                 GimpMergeType  merge_type)
+gboolean
+_gimp_image_remove_vectors (gint32 image_ID,
+                            gint32 vectors_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_MERGE_TYPE, merge_type,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-merge-visible-layers",
+                                                "gimp-image-remove-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-merge-visible-layers",
+    return_vals = gimp_run_procedure_array ("gimp-image-remove-vectors",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return success;
 }
 
 /**
- * gimp_image_merge_down:
+ * gimp_image_freeze_vectors:
  * @image: 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.
+ * Freeze the image's vectors list.
  *
- * 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.
+ * 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.
  *
- * Returns: The resulting layer.
+ * 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
  **/
-gint32
-gimp_image_merge_down (GimpImage     *image,
-                       gint32         merge_layer_ID,
-                       GimpMergeType  merge_type)
+gboolean
+gimp_image_freeze_vectors (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_LAYER_ID, merge_layer_ID,
-                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-merge-down",
+                                                "gimp-image-freeze-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-merge-down",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-vectors",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return success;
 }
 
 /**
- * _gimp_image_get_colormap:
- * @image: The image.
- * @num_bytes: (out): Number of bytes in the colormap array.
+ * _gimp_image_freeze_vectors: (skip)
+ * @image_ID: The image.
  *
- * Returns the image's colormap
+ * Freeze the image's vectors list.
  *
- * 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.
+ * 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.
  *
- * Returns: (array length=num_bytes) (element-type guint8) (transfer full):
- *          The image's colormap.
- *          The returned value must be freed with g_free().
+ * 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
  **/
-guint8 *
-_gimp_image_get_colormap (GimpImage *image,
-                          gint      *num_bytes)
+gboolean
+_gimp_image_freeze_vectors (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  guint8 *colormap = NULL;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-colormap",
+                                                "gimp-image-freeze-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-colormap",
+    return_vals = gimp_run_procedure_array ("gimp-image-freeze-vectors",
                                             args);
   gimp_value_array_unref (args);
 
-  *num_bytes = 0;
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      colormap = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
-    }
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return colormap;
+  return success;
 }
 
 /**
- * _gimp_image_set_colormap:
+ * gimp_image_thaw_vectors:
  * @image: The image.
- * @num_bytes: Number of bytes in the colormap array.
- * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
  *
- * Sets the entries in the image's colormap.
+ * Thaw the image's vectors list.
  *
- * 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.
+ * 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_set_colormap (GimpImage    *image,
-                          gint          num_bytes,
-                          const guint8 *colormap)
+gimp_image_thaw_vectors (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2010,17 +2892,14 @@ _gimp_image_set_colormap (GimpImage    *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_INT, num_bytes,
-                                          GIMP_TYPE_UINT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-colormap",
+                                                "gimp-image-thaw-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-colormap",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-vectors",
                                             args);
   gimp_value_array_unref (args);
 
@@ -2032,200 +2911,204 @@ _gimp_image_set_colormap (GimpImage    *image,
 }
 
 /**
- * _gimp_image_get_metadata:
- * @image: The image.
+ * _gimp_image_thaw_vectors: (skip)
+ * @image_ID: The image.
  *
- * Returns the image's metadata.
+ * Thaw the image's vectors list.
  *
- * Returns exif/iptc/xmp metadata from the image.
+ * This procedure thaws the vectors list of the image, re-enabling
+ * updates to the Paths dialog.
  *
- * Returns: (transfer full): The exif/ptc/xmp metadata as a string.
- *          The returned value must be freed with g_free().
+ * This procedure should match a corresponding call to
+ * gimp_image_freeze_vectors().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10.2
  **/
-gchar *
-_gimp_image_get_metadata (GimpImage *image)
+gboolean
+_gimp_image_thaw_vectors (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *metadata_string = NULL;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-metadata",
+                                                "gimp-image-thaw-vectors",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-metadata",
+    return_vals = gimp_run_procedure_array ("gimp-image-thaw-vectors",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return metadata_string;
+  return success;
 }
 
 /**
- * _gimp_image_set_metadata:
+ * gimp_image_get_item_position:
  * @image: The image.
- * @metadata_string: The exif/ptc/xmp metadata as a string.
+ * @item_ID: The item.
  *
- * Set the image's metadata.
+ * Returns the position of the item in its level of its item tree.
  *
- * Sets exif/iptc/xmp metadata on the image.
+ * 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: TRUE on success.
+ * Returns: The position of the item in its level in the item tree.
+ *
+ * Since: 2.8
  **/
-gboolean
-_gimp_image_set_metadata (GimpImage   *image,
-                          const gchar *metadata_string)
+gint
+gimp_image_get_item_position (GimpImage *image,
+                              gint32     item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint position = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_STRING, metadata_string,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-metadata",
+                                                "gimp-image-get-item-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-metadata",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-item-position",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    position = g_value_get_int (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return position;
 }
 
 /**
- * gimp_image_clean_all:
- * @image: The image.
+ * _gimp_image_get_item_position: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item.
  *
- * Set the image dirty count to 0.
+ * Returns the position of the item in its level of its item tree.
  *
- * 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.
+ * 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: TRUE on success.
+ * Returns: The position of the item in its level in the item tree.
+ *
+ * Since: 2.8
  **/
-gboolean
-gimp_image_clean_all (GimpImage *image)
+gint
+_gimp_image_get_item_position (gint32 image_ID,
+                               gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint position = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-clean-all",
+                                                "gimp-image-get-item-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-clean-all",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-item-position",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    position = g_value_get_int (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return position;
 }
 
 /**
- * gimp_image_is_dirty:
+ * gimp_image_raise_item:
  * @image: The image.
+ * @item_ID: The item to raise.
  *
- * Checks if the image has unsaved changes.
+ * Raise the specified item in its level in its item tree
  *
- * 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.
+ * 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 if the image has unsaved changes.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
 gboolean
-gimp_image_is_dirty (GimpImage *image)
+gimp_image_raise_item (GimpImage *image,
+                       gint32     item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean dirty = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-is-dirty",
+                                                "gimp-image-raise-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-is-dirty",
+    return_vals = gimp_run_procedure_array ("gimp-image-raise-item",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    dirty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return dirty;
+  return success;
 }
 
 /**
- * _gimp_image_thumbnail:
- * @image: The image.
- * @width: The requested thumbnail width.
- * @height: The requested thumbnail height.
- * @actual_width: (out): The previews width.
- * @actual_height: (out): The previews height.
- * @bpp: (out): The previews bpp.
- * @thumbnail_data_count: (out): The number of bytes in thumbnail data.
- * @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The 
thumbnail data.
+ * _gimp_image_raise_item: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item to raise.
  *
- * Get a thumbnail of an image.
+ * Raise the specified item in its level in its item tree
  *
- * 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.
+ * 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_thumbnail (GimpImage  *image,
-                       gint        width,
-                       gint        height,
-                       gint       *actual_width,
-                       gint       *actual_height,
-                       gint       *bpp,
-                       gint       *thumbnail_data_count,
-                       guint8    **thumbnail_data)
+_gimp_image_raise_item (gint32 image_ID,
+                        gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2233,100 +3116,87 @@ _gimp_image_thumbnail (GimpImage  *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_INT, width,
-                                          G_TYPE_INT, height,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-thumbnail",
+                                                "gimp-image-raise-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-thumbnail",
+    return_vals = gimp_run_procedure_array ("gimp-image-raise-item",
                                             args);
   gimp_value_array_unref (args);
 
-  *actual_width = 0;
-  *actual_height = 0;
-  *bpp = 0;
-  *thumbnail_data_count = 0;
-  *thumbnail_data = NULL;
-
   success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
-  if (success)
-    {
-      *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
-      *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
-      *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
-      *thumbnail_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 5));
-    }
-
   gimp_value_array_unref (return_vals);
 
   return success;
 }
 
 /**
- * gimp_image_get_active_layer:
+ * gimp_image_lower_item:
  * @image: The image.
+ * @item_ID: The item to lower.
  *
- * Returns the specified image's active layer.
+ * Lower the specified item in its level in its item tree
  *
- * 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.
+ * 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: The active layer.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
-gint32
-gimp_image_get_active_layer (GimpImage *image)
+gboolean
+gimp_image_lower_item (GimpImage *image,
+                       gint32     item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 active_layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-active-layer",
+                                                "gimp-image-lower-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-active-layer",
+    return_vals = gimp_run_procedure_array ("gimp-image-lower-item",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    active_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return active_layer_ID;
+  return success;
 }
 
 /**
- * gimp_image_set_active_layer:
- * @image: The image.
- * @active_layer_ID: The new image active layer.
+ * _gimp_image_lower_item: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item to lower.
  *
- * Sets the specified image's active layer.
+ * Lower the specified item in its level in its item tree
  *
- * 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.
+ * 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_set_active_layer (GimpImage *image,
-                             gint32     active_layer_ID)
+_gimp_image_lower_item (gint32 image_ID,
+                        gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2334,16 +3204,16 @@ gimp_image_set_active_layer (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_LAYER_ID, active_layer_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-active-layer",
+                                                "gimp-image-lower-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-active-layer",
+    return_vals = gimp_run_procedure_array ("gimp-image-lower-item",
                                             args);
   gimp_value_array_unref (args);
 
@@ -2355,62 +3225,66 @@ gimp_image_set_active_layer (GimpImage *image,
 }
 
 /**
- * gimp_image_get_active_channel:
+ * gimp_image_raise_item_to_top:
  * @image: The image.
+ * @item_ID: The item to raise to top.
  *
- * Returns the specified image's active channel.
+ * Raise the specified item to the top of its level in its item tree
  *
- * If there is an active channel, this will return the channel ID,
- * otherwise, -1.
+ * 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: The active channel.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
-gint32
-gimp_image_get_active_channel (GimpImage *image)
+gboolean
+gimp_image_raise_item_to_top (GimpImage *image,
+                              gint32     item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 active_channel_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-active-channel",
+                                                "gimp-image-raise-item-to-top",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-active-channel",
+    return_vals = gimp_run_procedure_array ("gimp-image-raise-item-to-top",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    active_channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return active_channel_ID;
+  return success;
 }
 
 /**
- * gimp_image_set_active_channel:
- * @image: The image.
- * @active_channel_ID: The new image active channel.
+ * _gimp_image_raise_item_to_top: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item to raise to top.
  *
- * Sets the specified image's active channel.
+ * Raise the specified item to the top of its level in its item tree
  *
- * 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.
+ * 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_set_active_channel (GimpImage *image,
-                               gint32     active_channel_ID)
+_gimp_image_raise_item_to_top (gint32 image_ID,
+                               gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2418,16 +3292,16 @@ gimp_image_set_active_channel (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_ID, active_channel_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-active-channel",
+                                                "gimp-image-raise-item-to-top",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-active-channel",
+    return_vals = gimp_run_procedure_array ("gimp-image-raise-item-to-top",
                                             args);
   gimp_value_array_unref (args);
 
@@ -2439,58 +3313,68 @@ gimp_image_set_active_channel (GimpImage *image,
 }
 
 /**
- * gimp_image_get_active_vectors:
+ * gimp_image_lower_item_to_bottom:
  * @image: The image.
+ * @item_ID: The item to lower to bottom.
  *
- * Returns the specified image's active vectors.
+ * Lower the specified item to the bottom of its level in its item tree
  *
- * If there is an active path, its ID will be returned, otherwise, -1.
+ * 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: The active vectors.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
-gint32
-gimp_image_get_active_vectors (GimpImage *image)
+gboolean
+gimp_image_lower_item_to_bottom (GimpImage *image,
+                                 gint32     item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 active_vectors_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-active-vectors",
+                                                "gimp-image-lower-item-to-bottom",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-active-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-lower-item-to-bottom",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    active_vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return active_vectors_ID;
+  return success;
 }
 
 /**
- * gimp_image_set_active_vectors:
- * @image: The image.
- * @active_vectors_ID: The new image active vectors.
+ * _gimp_image_lower_item_to_bottom: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item to lower to bottom.
  *
- * Sets the specified image's active vectors.
+ * Lower the specified item to the bottom of its level in its item tree
  *
- * If the path exists, it is set as the active path in the image.
+ * 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_set_active_vectors (GimpImage *image,
-                               gint32     active_vectors_ID)
+_gimp_image_lower_item_to_bottom (gint32 image_ID,
+                                  gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2498,16 +3382,16 @@ gimp_image_set_active_vectors (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_VECTORS_ID, active_vectors_ID,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-active-vectors",
+                                                "gimp-image-lower-item-to-bottom",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-active-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-image-lower-item-to-bottom",
                                             args);
   gimp_value_array_unref (args);
 
@@ -2519,255 +3403,2077 @@ gimp_image_set_active_vectors (GimpImage *image,
 }
 
 /**
- * gimp_image_get_selection:
+ * gimp_image_reorder_item:
  * @image: The image.
+ * @item_ID: The item to reorder.
+ * @parent_ID: The new parent item.
+ * @position: The new position of the item.
  *
- * Returns the specified image's selection.
+ * Reorder the specified item within its item tree
  *
- * This will always return a valid ID for a selection -- which is
- * represented as a channel internally.
+ * This procedure reorders the specified item within its item tree.
  *
- * Returns: The selection channel.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
-gint32
-gimp_image_get_selection (GimpImage *image)
+gboolean
+gimp_image_reorder_item (GimpImage *image,
+                         gint32     item_ID,
+                         gint32     parent_ID,
+                         gint       position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 selection_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, parent_ID,
+                                          G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-selection",
+                                                "gimp-image-reorder-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-selection",
+    return_vals = gimp_run_procedure_array ("gimp-image-reorder-item",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    selection_ID = gimp_value_get_selection_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return selection_ID;
+  return success;
 }
 
 /**
- * gimp_image_get_component_active:
- * @image: The image.
- * @component: The image component.
+ * _gimp_image_reorder_item: (skip)
+ * @image_ID: The image.
+ * @item_ID: The item to reorder.
+ * @parent_ID: The new parent item.
+ * @position: The new position of the item.
  *
- * Returns if the specified image's image component is active.
+ * Reorder the specified item within its item tree
  *
- * 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.
+ * This procedure reorders the specified item within its item tree.
  *
- * Returns: Component is active.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
  **/
 gboolean
-gimp_image_get_component_active (GimpImage       *image,
-                                 GimpChannelType  component)
+_gimp_image_reorder_item (gint32 image_ID,
+                          gint32 item_ID,
+                          gint32 parent_ID,
+                          gint   position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean active = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, parent_ID,
+                                          G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-component-active",
+                                                "gimp-image-reorder-item",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-component-active",
+    return_vals = gimp_run_procedure_array ("gimp-image-reorder-item",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    active = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return active;
+  return success;
 }
 
 /**
- * gimp_image_set_component_active:
+ * gimp_image_flatten:
  * @image: The image.
- * @component: The image component.
- * @active: Component is active.
  *
- * Sets if the specified image's image component is active.
+ * Flatten all visible layers into a single layer. Discard all
+ * invisible layers.
  *
- * 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.
+ * 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: TRUE on success.
+ * Returns: The resulting layer.
  **/
-gboolean
-gimp_image_set_component_active (GimpImage       *image,
-                                 GimpChannelType  component,
-                                 gboolean         active)
+gint32
+gimp_image_flatten (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_TYPE, component,
-                                          G_TYPE_BOOLEAN, active,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-component-active",
+                                                "gimp-image-flatten",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-component-active",
+    return_vals = gimp_run_procedure_array ("gimp-image-flatten",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return layer_ID;
 }
 
 /**
- * gimp_image_get_component_visible:
- * @image: The image.
- * @component: The image component.
+ * _gimp_image_flatten: (skip)
+ * @image_ID: The image.
  *
- * Returns if the specified image's image component is visible.
+ * Flatten all visible layers into a single layer. Discard all
+ * invisible layers.
  *
- * 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.
+ * 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: Component is visible.
+ * Returns: The resulting layer.
  **/
-gboolean
-gimp_image_get_component_visible (GimpImage       *image,
-                                  GimpChannelType  component)
+gint32
+_gimp_image_flatten (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean visible = FALSE;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-component-visible",
+                                                "gimp-image-flatten",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-component-visible",
+    return_vals = gimp_run_procedure_array ("gimp-image-flatten",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return visible;
+  return layer_ID;
 }
 
 /**
- * gimp_image_set_component_visible:
+ * gimp_image_merge_visible_layers:
  * @image: The image.
- * @component: The image component.
- * @visible: Component is visible.
+ * @merge_type: The type of merge.
  *
- * Sets if the specified image's image component is visible.
+ * Merge the visible image layers into one.
  *
- * 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.
+ * 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: TRUE on success.
+ * Returns: The resulting layer.
  **/
-gboolean
-gimp_image_set_component_visible (GimpImage       *image,
-                                  GimpChannelType  component,
-                                  gboolean         visible)
+gint32
+gimp_image_merge_visible_layers (GimpImage     *image,
+                                 GimpMergeType  merge_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_CHANNEL_TYPE, component,
-                                          G_TYPE_BOOLEAN, visible,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-component-visible",
+                                                "gimp-image-merge-visible-layers",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-component-visible",
+    return_vals = gimp_run_procedure_array ("gimp-image-merge-visible-layers",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return layer_ID;
 }
 
 /**
- * gimp_image_get_filename:
- * @image: The image.
+ * _gimp_image_merge_visible_layers: (skip)
+ * @image_ID: The image.
+ * @merge_type: The type of merge.
  *
- * Returns the specified image's filename.
+ * Merge the visible image layers into one.
  *
- * 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().
+ * This procedure combines the visible layers into a single layer using
+ * the specified merge type. A merge type of EXPAND_AS_NECESSARY
+ * expands the final layer to encompass the areas of the visible
+ * layers. A merge type of CLIP_TO_IMAGE clips the final layer to the
+ * extents of the image. A merge type of CLIP_TO_BOTTOM_LAYER clips the
+ * final layer to the size of the bottommost layer.
  *
- * Returns: (transfer full): The filename.
- *          The returned value must be freed with g_free().
+ * Returns: The resulting layer.
  **/
-gchar *
-gimp_image_get_filename (GimpImage *image)
+gint32
+_gimp_image_merge_visible_layers (gint32        image_ID,
+                                  GimpMergeType merge_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *filename = NULL;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-merge-visible-layers",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-merge-visible-layers",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_image_merge_down:
+ * @image: 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 (GimpImage     *image,
+                       gint32         merge_layer_ID,
+                       GimpMergeType  merge_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_LAYER_ID, merge_layer_ID,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-merge-down",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-merge-down",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
+/**
+ * _gimp_image_merge_down: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, merge_layer_ID,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-merge-down",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-merge-down",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
+/**
+ * _gimp_image_get_colormap:
+ * @image: The image.
+ * @num_bytes: (out): Number of bytes in the colormap array.
+ *
+ * Returns the image's colormap
+ *
+ * This procedure returns an actual pointer to the image's colormap, as
+ * well as the number of bytes contained in the colormap. The actual
+ * number of colors in the transmitted colormap will be 'num-bytes' /
+ * 3. If the image is not in Indexed color mode, no colormap is
+ * returned.
+ *
+ * Returns: (array length=num_bytes) (element-type guint8) (transfer full):
+ *          The image's colormap.
+ *          The returned value must be freed with g_free().
+ **/
+guint8 *
+_gimp_image_get_colormap (GimpImage *image,
+                          gint      *num_bytes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  guint8 *colormap = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-colormap",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-colormap",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_bytes = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      colormap = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return colormap;
+}
+
+/**
+ * __gimp_image_get_colormap: (skip)
+ * @image_ID: The image.
+ * @num_bytes: (out): Number of bytes in the colormap array.
+ *
+ * Returns the image's colormap
+ *
+ * This procedure returns an actual pointer to the image's colormap, as
+ * well as the number of bytes contained in the colormap. The actual
+ * number of colors in the transmitted colormap will be 'num-bytes' /
+ * 3. If the image is not in Indexed color mode, no colormap is
+ * returned.
+ *
+ * Returns: (array length=num_bytes): The image's colormap.
+ *          The returned value must be freed with g_free().
+ **/
+guint8 *
+__gimp_image_get_colormap (gint32  image_ID,
+                           gint   *num_bytes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  guint8 *colormap = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-colormap",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-colormap",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_bytes = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      colormap = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return colormap;
+}
+
+/**
+ * _gimp_image_set_colormap:
+ * @image: The image.
+ * @num_bytes: Number of bytes in the colormap array.
+ * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
+ *
+ * Sets the entries in the image's colormap.
+ *
+ * This procedure sets the entries in the specified image's colormap.
+ * The number of entries is specified by the 'num-bytes' parameter and
+ * corresponds to the number of INT8 triples that must be contained in
+ * the 'colormap' array. The actual number of colors in the transmitted
+ * colormap is 'num-bytes' / 3.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_set_colormap (GimpImage    *image,
+                          gint          num_bytes,
+                          const guint8 *colormap)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_INT, num_bytes,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-colormap",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-colormap",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * __gimp_image_set_colormap: (skip)
+ * @image_ID: The image.
+ * @num_bytes: Number of bytes in the colormap array.
+ * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
+ *
+ * Sets the entries in the image's colormap.
+ *
+ * This procedure sets the entries in the specified image's colormap.
+ * The number of entries is specified by the 'num-bytes' parameter and
+ * corresponds to the number of INT8 triples that must be contained in
+ * the 'colormap' array. The actual number of colors in the transmitted
+ * colormap is 'num-bytes' / 3.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+__gimp_image_set_colormap (gint32        image_ID,
+                           gint          num_bytes,
+                           const guint8 *colormap)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, num_bytes,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-colormap",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-colormap",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_get_metadata:
+ * @image: The image.
+ *
+ * Returns the image's metadata.
+ *
+ * Returns exif/iptc/xmp metadata from the image.
+ *
+ * Returns: (transfer full): The exif/ptc/xmp metadata as a string.
+ *          The returned value must be freed with g_free().
+ **/
+gchar *
+_gimp_image_get_metadata (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *metadata_string = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-metadata",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-metadata",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return metadata_string;
+}
+
+/**
+ * __gimp_image_get_metadata: (skip)
+ * @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.
+ *          The returned value must be freed with g_free().
+ **/
+gchar *
+__gimp_image_get_metadata (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *metadata_string = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-metadata",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-metadata",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return metadata_string;
+}
+
+/**
+ * _gimp_image_set_metadata:
+ * @image: The image.
+ * @metadata_string: The exif/ptc/xmp metadata as a string.
+ *
+ * Set the image's metadata.
+ *
+ * Sets exif/iptc/xmp metadata on the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_set_metadata (GimpImage   *image,
+                          const gchar *metadata_string)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_STRING, metadata_string,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-metadata",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-metadata",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * __gimp_image_set_metadata: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, metadata_string,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-metadata",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-metadata",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_clean_all:
+ * @image: The image.
+ *
+ * Set the image dirty count to 0.
+ *
+ * This procedure sets the specified image's dirty count to 0, allowing
+ * operations to occur without having a 'dirtied' image. This is
+ * especially useful for creating and loading images which should not
+ * initially be considered dirty, even though layers must be created,
+ * filled, and installed in the image. Note that save plug-ins must NOT
+ * call this function themselves after saving the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_clean_all (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-clean-all",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-clean-all",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_clean_all: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-clean-all",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-clean-all",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_is_dirty:
+ * @image: The image.
+ *
+ * Checks if the image has unsaved changes.
+ *
+ * This procedure checks the specified image's dirty count to see if it
+ * needs to be saved. Note that saving the image does not automatically
+ * set the dirty count to 0, you need to call gimp_image_clean_all()
+ * after calling a save procedure to make the image clean.
+ *
+ * Returns: TRUE if the image has unsaved changes.
+ **/
+gboolean
+gimp_image_is_dirty (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean dirty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-is-dirty",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-is-dirty",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    dirty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return dirty;
+}
+
+/**
+ * _gimp_image_is_dirty: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean dirty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-is-dirty",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-is-dirty",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    dirty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return dirty;
+}
+
+/**
+ * _gimp_image_thumbnail:
+ * @image: The image.
+ * @width: The requested thumbnail width.
+ * @height: The requested thumbnail height.
+ * @actual_width: (out): The previews width.
+ * @actual_height: (out): The previews height.
+ * @bpp: (out): The previews bpp.
+ * @thumbnail_data_count: (out): The number of bytes in thumbnail data.
+ * @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The 
thumbnail data.
+ *
+ * Get a thumbnail of an image.
+ *
+ * This function gets data from which a thumbnail of an image preview
+ * can be created. Maximum x or y dimension is 1024 pixels. The pixels
+ * are returned in RGB[A] or GRAY[A] format. The bpp return value gives
+ * the number of bits per pixel in the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_thumbnail (GimpImage  *image,
+                       gint        width,
+                       gint        height,
+                       gint       *actual_width,
+                       gint       *actual_height,
+                       gint       *bpp,
+                       gint       *thumbnail_data_count,
+                       guint8    **thumbnail_data)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-thumbnail",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-thumbnail",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *actual_width = 0;
+  *actual_height = 0;
+  *bpp = 0;
+  *thumbnail_data_count = 0;
+  *thumbnail_data = NULL;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+      *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+      *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
+      *thumbnail_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 5));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * __gimp_image_thumbnail: (skip)
+ * @image_ID: The image.
+ * @width: The requested thumbnail width.
+ * @height: The requested thumbnail height.
+ * @actual_width: (out): The previews width.
+ * @actual_height: (out): The previews height.
+ * @bpp: (out): The previews bpp.
+ * @thumbnail_data_count: (out): The number of bytes in thumbnail data.
+ * @thumbnail_data: (out) (array length=thumbnail_data_count): 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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-thumbnail",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-thumbnail",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *actual_width = 0;
+  *actual_height = 0;
+  *bpp = 0;
+  *thumbnail_data_count = 0;
+  *thumbnail_data = NULL;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+      *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+      *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
+      *thumbnail_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 5));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_layer:
+ * @image: The image.
+ *
+ * Returns the specified image's active layer.
+ *
+ * If there is an active layer, its ID will be returned, otherwise, -1.
+ * If a channel is currently active, then no layer will be. If a layer
+ * mask is active, then this will return the associated layer.
+ *
+ * Returns: The active layer.
+ **/
+gint32
+gimp_image_get_active_layer (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_layer_ID;
+}
+
+/**
+ * _gimp_image_get_active_layer: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_layer_ID;
+}
+
+/**
+ * gimp_image_set_active_layer:
+ * @image: 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 (GimpImage *image,
+                             gint32     active_layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_LAYER_ID, active_layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_active_layer: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, active_layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_channel:
+ * @image: The image.
+ *
+ * Returns the specified image's active channel.
+ *
+ * If there is an active channel, this will return the channel ID,
+ * otherwise, -1.
+ *
+ * Returns: The active channel.
+ **/
+gint32
+gimp_image_get_active_channel (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_channel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-channel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-channel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_channel_ID;
+}
+
+/**
+ * _gimp_image_get_active_channel: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_channel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-channel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-channel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_channel_ID;
+}
+
+/**
+ * gimp_image_set_active_channel:
+ * @image: 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 (GimpImage *image,
+                               gint32     active_channel_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_ID, active_channel_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-channel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-channel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_active_channel: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, active_channel_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-channel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-channel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_active_vectors:
+ * @image: The image.
+ *
+ * Returns the specified image's active vectors.
+ *
+ * If there is an active path, its ID will be returned, otherwise, -1.
+ *
+ * Returns: The active vectors.
+ **/
+gint32
+gimp_image_get_active_vectors (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_vectors_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_vectors_ID;
+}
+
+/**
+ * _gimp_image_get_active_vectors: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 active_vectors_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-active-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-active-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active_vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active_vectors_ID;
+}
+
+/**
+ * gimp_image_set_active_vectors:
+ * @image: 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 (GimpImage *image,
+                               gint32     active_vectors_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_VECTORS_ID, active_vectors_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_active_vectors: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, active_vectors_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-active-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-active-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_selection:
+ * @image: The image.
+ *
+ * Returns the specified image's selection.
+ *
+ * This will always return a valid ID for a selection -- which is
+ * represented as a channel internally.
+ *
+ * Returns: The selection channel.
+ **/
+gint32
+gimp_image_get_selection (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 selection_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-selection",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-selection",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    selection_ID = gimp_value_get_selection_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return selection_ID;
+}
+
+/**
+ * _gimp_image_get_selection: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 selection_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-selection",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-selection",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    selection_ID = gimp_value_get_selection_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return selection_ID;
+}
+
+/**
+ * gimp_image_get_component_active:
+ * @image: The image.
+ * @component: The image component.
+ *
+ * Returns if the specified image's image component is active.
+ *
+ * This procedure returns if the specified image's image component
+ * (i.e. Red, Green, Blue intensity channels in an RGB image) is active
+ * or inactive -- whether or not it can be modified. If the specified
+ * component is not valid for the image type, an error is returned.
+ *
+ * Returns: Component is active.
+ **/
+gboolean
+gimp_image_get_component_active (GimpImage       *image,
+                                 GimpChannelType  component)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean active = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-component-active",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-component-active",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active;
+}
+
+/**
+ * _gimp_image_get_component_active: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean active = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-component-active",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-component-active",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    active = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return active;
+}
+
+/**
+ * gimp_image_set_component_active:
+ * @image: The image.
+ * @component: The image component.
+ * @active: Component is active.
+ *
+ * Sets if the specified image's image component is active.
+ *
+ * This procedure sets if the specified image's image component (i.e.
+ * Red, Green, Blue intensity channels in an RGB image) is active or
+ * inactive -- whether or not it can be modified. If the specified
+ * component is not valid for the image type, an error is returned.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_set_component_active (GimpImage       *image,
+                                 GimpChannelType  component,
+                                 gboolean         active)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, active,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-component-active",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-component-active",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_component_active: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, active,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-component-active",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-component-active",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_component_visible:
+ * @image: The image.
+ * @component: The image component.
+ *
+ * Returns if the specified image's image component is visible.
+ *
+ * This procedure returns if the specified image's image component
+ * (i.e. Red, Green, Blue intensity channels in an RGB image) is
+ * visible or invisible -- whether or not it can be seen. If the
+ * specified component is not valid for the image type, an error is
+ * returned.
+ *
+ * Returns: Component is visible.
+ **/
+gboolean
+gimp_image_get_component_visible (GimpImage       *image,
+                                  GimpChannelType  component)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean visible = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-component-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-component-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return visible;
+}
+
+/**
+ * _gimp_image_get_component_visible: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean visible = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-component-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-component-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return visible;
+}
+
+/**
+ * gimp_image_set_component_visible:
+ * @image: The image.
+ * @component: The image component.
+ * @visible: Component is visible.
+ *
+ * Sets if the specified image's image component is visible.
+ *
+ * This procedure sets if the specified image's image component (i.e.
+ * Red, Green, Blue intensity channels in an RGB image) is visible or
+ * invisible -- whether or not it can be seen. If the specified
+ * component is not valid for the image type, an error is returned.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_set_component_visible (GimpImage       *image,
+                                  GimpChannelType  component,
+                                  gboolean         visible)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, visible,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-component-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-component-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_component_visible: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, visible,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-component-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-component-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_filename:
+ * @image: 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: (transfer full): The filename.
+ *          The returned value must be freed with g_free().
+ **/
+gchar *
+gimp_image_get_filename (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *filename = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-filename",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-filename",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    filename = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return filename;
+}
+
+/**
+ * _gimp_image_get_filename: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *filename = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -2775,33 +5481,852 @@ gimp_image_get_filename (GimpImage *image)
                                                 "gimp-image-get-filename",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-filename",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-filename",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    filename = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return filename;
+}
+
+/**
+ * gimp_image_set_filename:
+ * @image: 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 (GimpImage   *image,
+                         const gchar *filename)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-filename",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-filename",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_filename: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-filename",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-filename",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_uri:
+ * @image: 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: (transfer full): The URI.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_uri (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * _gimp_image_get_uri: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_xcf_uri:
+ * @image: 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: (transfer full): The imported URI.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_xcf_uri (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-xcf-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-xcf-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * _gimp_image_get_xcf_uri: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-xcf-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-xcf-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_imported_uri:
+ * @image: 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: (transfer full): The imported URI.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_imported_uri (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-imported-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-imported-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * _gimp_image_get_imported_uri: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-imported-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-imported-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_exported_uri:
+ * @image: 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: (transfer full): The exported URI.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_image_get_exported_uri (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-exported-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-exported-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * _gimp_image_get_exported_uri: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *uri = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-exported-uri",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-exported-uri",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return uri;
+}
+
+/**
+ * gimp_image_get_name:
+ * @image: The image.
+ *
+ * Returns the specified image's name.
+ *
+ * This procedure returns the image's name. If the image has a filename
+ * or an URI, then the returned name contains the filename's or URI's
+ * base name (the last component of the path). Otherwise it is the
+ * translated string \"Untitled\". The returned name is formatted like
+ * the image name in the image window title, it may contain '[]',
+ * '(imported)' etc. and should only be used to label user interface
+ * elements. Never use it to construct filenames.
+ *
+ * Returns: (transfer full): The name.
+ *          The returned value must be freed with g_free().
+ **/
+gchar *
+gimp_image_get_name (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *name = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-name",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return name;
+}
+
+/**
+ * _gimp_image_get_name: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *name = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-name",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return name;
+}
+
+/**
+ * gimp_image_get_resolution:
+ * @image: The image.
+ * @xresolution: (out): The resolution in the x-axis, in dots per inch.
+ * @yresolution: (out): The resolution in the y-axis, in dots per inch.
+ *
+ * Returns the specified image's resolution.
+ *
+ * This procedure returns the specified image's resolution in dots per
+ * inch. This value is independent of any of the layers in this image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_get_resolution (GimpImage *image,
+                           gdouble   *xresolution,
+                           gdouble   *yresolution)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-resolution",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-resolution",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *xresolution = 0.0;
+  *yresolution = 0.0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *xresolution = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *yresolution = g_value_get_double (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_get_resolution: (skip)
+ * @image_ID: The image.
+ * @xresolution: (out): The resolution in the x-axis, in dots per inch.
+ * @yresolution: (out): The resolution in the y-axis, in dots per inch.
+ *
+ * Returns the specified image's resolution.
+ *
+ * This procedure returns the specified image's resolution in dots per
+ * inch. This value is independent of any of the layers in this image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_get_resolution (gint32   image_ID,
+                            gdouble *xresolution,
+                            gdouble *yresolution)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-resolution",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-resolution",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *xresolution = 0.0;
+  *yresolution = 0.0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *xresolution = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *yresolution = g_value_get_double (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_set_resolution:
+ * @image: The image.
+ * @xresolution: The new image resolution in the x-axis, in dots per inch.
+ * @yresolution: The new image resolution in the y-axis, in dots per inch.
+ *
+ * Sets the specified image's resolution.
+ *
+ * This procedure sets the specified image's resolution in dots per
+ * inch. This value is independent of any of the layers in this image.
+ * No scaling or resizing is performed.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_image_set_resolution (GimpImage *image,
+                           gdouble    xresolution,
+                           gdouble    yresolution)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_DOUBLE, xresolution,
+                                          G_TYPE_DOUBLE, yresolution,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-resolution",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-resolution",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_image_set_resolution: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xresolution,
+                                          G_TYPE_DOUBLE, yresolution,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-resolution",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-resolution",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_unit:
+ * @image: The image.
+ *
+ * Returns the specified image's unit.
+ *
+ * This procedure returns the specified image's unit. This value is
+ * independent of any of the layers in this image. See the
+ * gimp_unit_*() procedure definitions for the valid range of unit IDs
+ * and a description of the unit system.
+ *
+ * Returns: (transfer none): The unit.
+ **/
+GimpUnit
+gimp_image_get_unit (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpUnit unit = GIMP_UNIT_PIXEL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-unit",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-unit",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    unit = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return unit;
+}
+
+/**
+ * _gimp_image_get_unit: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpUnit unit = GIMP_UNIT_PIXEL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-unit",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-unit",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    filename = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    unit = g_value_get_int (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return filename;
+  return unit;
 }
 
 /**
- * gimp_image_set_filename:
+ * gimp_image_set_unit:
  * @image: The image.
- * @filename: The new image filename.
+ * @unit: The new image unit.
  *
- * Sets the specified image's filename.
+ * Sets the specified image's unit.
  *
- * This procedure sets the specified image's filename. The filename
- * should be in the filesystem encoding.
+ * 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_filename (GimpImage   *image,
-                         const gchar *filename)
+gimp_image_set_unit (GimpImage *image,
+                     GimpUnit   unit)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2810,15 +6335,15 @@ gimp_image_set_filename (GimpImage   *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_STRING, filename,
+                                          GIMP_TYPE_UNIT, unit,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-filename",
+                                                "gimp-image-set-unit",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-filename",
+    return_vals = gimp_run_procedure_array ("gimp-image-set-unit",
                                             args);
   gimp_value_array_unref (args);
 
@@ -2830,31 +6355,69 @@ gimp_image_set_filename (GimpImage   *image,
 }
 
 /**
- * gimp_image_get_uri:
- * @image: The image.
+ * _gimp_image_set_unit: (skip)
+ * @image_ID: The image.
+ * @unit: The new image unit.
  *
- * Returns the URI for the specified image.
+ * Sets the specified image's unit.
  *
- * 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.
+ * 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: (transfer full): The URI.
- *          The returned value must be freed with g_free().
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_set_unit (gint32   image_ID,
+                      GimpUnit unit)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_UNIT, unit,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-unit",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-unit",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_tattoo_state:
+ * @image: The image.
  *
- * Since: 2.8
+ * 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.
  **/
-gchar *
-gimp_image_get_uri (GimpImage *image)
+guint
+gimp_image_get_tattoo_state (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *uri = NULL;
+  guint tattoo_state = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -2862,535 +6425,580 @@ gimp_image_get_uri (GimpImage *image)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-uri",
+                                                "gimp-image-get-tattoo-state",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-uri",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-tattoo-state",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    tattoo_state = g_value_get_uint (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return uri;
+  return tattoo_state;
 }
 
 /**
- * gimp_image_get_xcf_uri:
- * @image: The image.
- *
- * Returns the XCF URI for the specified image.
+ * _gimp_image_get_tattoo_state: (skip)
+ * @image_ID: The image.
  *
- * This procedure returns the XCF URI associated with the image. If
- * there is no such URI, this procedure returns %NULL.
+ * Returns the tattoo state associated with the image.
  *
- * Returns: (transfer full): The imported URI.
- *          The returned value must be freed with g_free().
+ * 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.
  *
- * Since: 2.8
+ * Returns: The tattoo state.
  **/
-gchar *
-gimp_image_get_xcf_uri (GimpImage *image)
+guint
+_gimp_image_get_tattoo_state (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *uri = NULL;
+  guint tattoo_state = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-xcf-uri",
+                                                "gimp-image-get-tattoo-state",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-xcf-uri",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-tattoo-state",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    tattoo_state = g_value_get_uint (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return uri;
+  return tattoo_state;
 }
 
 /**
- * gimp_image_get_imported_uri:
+ * gimp_image_set_tattoo_state:
  * @image: The image.
+ * @tattoo_state: The new image tattoo state.
  *
- * 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.
+ * Set the tattoo state associated with the image.
  *
- * Returns: (transfer full): The imported URI.
- *          The returned value must be freed with g_free().
+ * 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.
  *
- * Since: 2.8
+ * Returns: TRUE on success.
  **/
-gchar *
-gimp_image_get_imported_uri (GimpImage *image)
+gboolean
+gimp_image_set_tattoo_state (GimpImage *image,
+                             guint      tattoo_state)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *uri = NULL;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_UINT, tattoo_state,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-imported-uri",
+                                                "gimp-image-set-tattoo-state",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-imported-uri",
+    return_vals = gimp_run_procedure_array ("gimp-image-set-tattoo-state",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return uri;
+  return success;
 }
 
 /**
- * gimp_image_get_exported_uri:
- * @image: The image.
+ * _gimp_image_set_tattoo_state: (skip)
+ * @image_ID: The image.
+ * @tattoo_state: The new image tattoo state.
  *
- * Returns the exported URI for the specified image.
+ * Set the tattoo state associated with the 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.
+ * 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: (transfer full): The exported URI.
- *          The returned value must be freed with g_free().
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_set_tattoo_state (gint32 image_ID,
+                              guint  tattoo_state)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, tattoo_state,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-tattoo-state",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-tattoo-state",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_image_get_layer_by_tattoo:
+ * @image: The image.
+ * @tattoo: The tattoo of the layer to find.
  *
- * Since: 2.8
+ * 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.
  **/
-gchar *
-gimp_image_get_exported_uri (GimpImage *image)
+gint32
+gimp_image_get_layer_by_tattoo (GimpImage *image,
+                                guint      tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *uri = NULL;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-exported-uri",
+                                                "gimp-image-get-layer-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-exported-uri",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return uri;
+  return layer_ID;
 }
 
 /**
- * gimp_image_get_name:
- * @image: The image.
+ * _gimp_image_get_layer_by_tattoo: (skip)
+ * @image_ID: The image.
+ * @tattoo: The tattoo of the layer to find.
  *
- * Returns the specified image's name.
+ * Find a layer with a given tattoo in an image.
  *
- * 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.
+ * This procedure returns the layer with the given tattoo in the
+ * specified image.
  *
- * Returns: (transfer full): The name.
- *          The returned value must be freed with g_free().
+ * Returns: The layer with the specified tattoo.
  **/
-gchar *
-gimp_image_get_name (GimpImage *image)
+gint32
+_gimp_image_get_layer_by_tattoo (gint32 image_ID,
+                                 guint  tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *name = NULL;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-name",
+                                                "gimp-image-get-layer-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-name",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return name;
+  return layer_ID;
 }
 
 /**
- * gimp_image_get_resolution:
+ * gimp_image_get_channel_by_tattoo:
  * @image: The image.
- * @xresolution: (out): The resolution in the x-axis, in dots per inch.
- * @yresolution: (out): The resolution in the y-axis, in dots per inch.
+ * @tattoo: The tattoo of the channel to find.
  *
- * Returns the specified image's resolution.
+ * Find a channel with a given tattoo in an image.
  *
- * This procedure returns the specified image's resolution in dots per
- * inch. This value is independent of any of the layers in this image.
+ * This procedure returns the channel with the given tattoo in the
+ * specified image.
  *
- * Returns: TRUE on success.
+ * Returns: The channel with the specified tattoo.
  **/
-gboolean
-gimp_image_get_resolution (GimpImage *image,
-                           gdouble   *xresolution,
-                           gdouble   *yresolution)
+gint32
+gimp_image_get_channel_by_tattoo (GimpImage *image,
+                                  guint      tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 channel_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-resolution",
+                                                "gimp-image-get-channel-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-resolution",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
-  *xresolution = 0.0;
-  *yresolution = 0.0;
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  if (success)
-    {
-      *xresolution = g_value_get_double (gimp_value_array_index (return_vals, 1));
-      *yresolution = g_value_get_double (gimp_value_array_index (return_vals, 2));
-    }
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return channel_ID;
 }
 
 /**
- * gimp_image_set_resolution:
- * @image: The image.
- * @xresolution: The new image resolution in the x-axis, in dots per inch.
- * @yresolution: The new image resolution in the y-axis, in dots per inch.
+ * _gimp_image_get_channel_by_tattoo: (skip)
+ * @image_ID: The image.
+ * @tattoo: The tattoo of the channel to find.
  *
- * Sets the specified image's resolution.
+ * Find a channel with a given tattoo in an image.
  *
- * 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.
+ * This procedure returns the channel with the given tattoo in the
+ * specified image.
  *
- * Returns: TRUE on success.
+ * Returns: The channel with the specified tattoo.
  **/
-gboolean
-gimp_image_set_resolution (GimpImage *image,
-                           gdouble    xresolution,
-                           gdouble    yresolution)
+gint32
+_gimp_image_get_channel_by_tattoo (gint32 image_ID,
+                                   guint  tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 channel_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_DOUBLE, xresolution,
-                                          G_TYPE_DOUBLE, yresolution,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-resolution",
+                                                "gimp-image-get-channel-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-resolution",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return channel_ID;
 }
 
 /**
- * gimp_image_get_unit:
+ * gimp_image_get_vectors_by_tattoo:
  * @image: The image.
+ * @tattoo: The tattoo of the vectors to find.
  *
- * Returns the specified image's unit.
+ * Find a vectors with a given tattoo in an image.
  *
- * 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.
+ * This procedure returns the vectors with the given tattoo in the
+ * specified image.
  *
- * Returns: (transfer none): The unit.
+ * Returns: The vectors with the specified tattoo.
+ *
+ * Since: 2.6
  **/
-GimpUnit
-gimp_image_get_unit (GimpImage *image)
+gint32
+gimp_image_get_vectors_by_tattoo (GimpImage *image,
+                                  guint      tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpUnit unit = GIMP_UNIT_PIXEL;
+  gint32 vectors_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-unit",
+                                                "gimp-image-get-vectors-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-unit",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    unit = g_value_get_int (gimp_value_array_index (return_vals, 1));
+    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return unit;
+  return vectors_ID;
 }
 
 /**
- * gimp_image_set_unit:
- * @image: The image.
- * @unit: The new image unit.
+ * _gimp_image_get_vectors_by_tattoo: (skip)
+ * @image_ID: The image.
+ * @tattoo: The tattoo of the vectors to find.
  *
- * Sets the specified image's unit.
+ * Find a vectors with a given tattoo in an image.
  *
- * 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.
+ * This procedure returns the vectors with the given tattoo in the
+ * specified image.
  *
- * Returns: TRUE on success.
+ * Returns: The vectors with the specified tattoo.
+ *
+ * Since: 2.6
  **/
-gboolean
-gimp_image_set_unit (GimpImage *image,
-                     GimpUnit   unit)
+gint32
+_gimp_image_get_vectors_by_tattoo (gint32 image_ID,
+                                   guint  tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 vectors_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_UNIT, unit,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-unit",
+                                                "gimp-image-get-vectors-by-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-unit",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return vectors_ID;
 }
 
 /**
- * gimp_image_get_tattoo_state:
+ * gimp_image_get_layer_by_name:
  * @image: The image.
+ * @name: The name of the layer to find.
  *
- * Returns the tattoo state associated with the image.
+ * Find a layer with a given name in an 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.
+ * This procedure returns the layer with the given name in the
+ * specified image.
  *
- * Returns: The tattoo state.
+ * Returns: The layer with the specified name.
+ *
+ * Since: 2.8
  **/
-guint
-gimp_image_get_tattoo_state (GimpImage *image)
+gint32
+gimp_image_get_layer_by_name (GimpImage   *image,
+                              const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  guint tattoo_state = 0;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-tattoo-state",
+                                                "gimp-image-get-layer-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-tattoo-state",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-name",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    tattoo_state = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return tattoo_state;
+  return layer_ID;
 }
 
 /**
- * gimp_image_set_tattoo_state:
- * @image: The image.
- * @tattoo_state: The new image tattoo state.
+ * _gimp_image_get_layer_by_name: (skip)
+ * @image_ID: The image.
+ * @name: The name of the layer to find.
  *
- * Set the tattoo state associated with the image.
+ * Find a layer with a given name in an 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.
+ * This procedure returns the layer with the given name in the
+ * specified image.
  *
- * Returns: TRUE on success.
+ * Returns: The layer with the specified name.
+ *
+ * Since: 2.8
  **/
-gboolean
-gimp_image_set_tattoo_state (GimpImage *image,
-                             guint      tattoo_state)
+gint32
+_gimp_image_get_layer_by_name (gint32       image_ID,
+                               const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gint32 layer_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_UINT, tattoo_state,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-tattoo-state",
+                                                "gimp-image-get-layer-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-tattoo-state",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-name",
                                             args);
   gimp_value_array_unref (args);
 
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return layer_ID;
 }
 
 /**
- * gimp_image_get_layer_by_tattoo:
+ * gimp_image_get_channel_by_name:
  * @image: The image.
- * @tattoo: The tattoo of the layer to find.
+ * @name: The name of the channel to find.
  *
- * Find a layer with a given tattoo in an image.
+ * Find a channel with a given name in an image.
  *
- * This procedure returns the layer with the given tattoo in the
+ * This procedure returns the channel with the given name in the
  * specified image.
  *
- * Returns: The layer with the specified tattoo.
+ * Returns: The channel with the specified name.
+ *
+ * Since: 2.8
  **/
 gint32
-gimp_image_get_layer_by_tattoo (GimpImage *image,
-                                guint      tattoo)
+gimp_image_get_channel_by_name (GimpImage   *image,
+                                const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gint32 channel_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_UINT, tattoo,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-layer-by-tattoo",
+                                                "gimp-image-get-channel-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-tattoo",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-name",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return channel_ID;
 }
 
 /**
- * gimp_image_get_channel_by_tattoo:
- * @image: The image.
- * @tattoo: The tattoo of the channel to find.
+ * _gimp_image_get_channel_by_name: (skip)
+ * @image_ID: The image.
+ * @name: The name of the channel to find.
  *
- * Find a channel with a given tattoo in an image.
+ * Find a channel with a given name in an image.
  *
- * This procedure returns the channel with the given tattoo in the
+ * This procedure returns the channel with the given name in the
  * specified image.
  *
- * Returns: The channel with the specified tattoo.
+ * Returns: The channel with the specified name.
+ *
+ * Since: 2.8
  **/
 gint32
-gimp_image_get_channel_by_tattoo (GimpImage *image,
-                                  guint      tattoo)
+_gimp_image_get_channel_by_name (gint32       image_ID,
+                                 const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3398,16 +7006,16 @@ gimp_image_get_channel_by_tattoo (GimpImage *image,
   gint32 channel_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_UINT, tattoo,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-channel-by-tattoo",
+                                                "gimp-image-get-channel-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-tattoo",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-name",
                                             args);
   gimp_value_array_unref (args);
 
@@ -3420,22 +7028,22 @@ gimp_image_get_channel_by_tattoo (GimpImage *image,
 }
 
 /**
- * gimp_image_get_vectors_by_tattoo:
+ * gimp_image_get_vectors_by_name:
  * @image: The image.
- * @tattoo: The tattoo of the vectors to find.
+ * @name: The name of the vectors to find.
  *
- * Find a vectors with a given tattoo in an image.
+ * Find a vectors with a given name in an image.
  *
- * This procedure returns the vectors with the given tattoo in the
+ * This procedure returns the vectors with the given name in the
  * specified image.
  *
- * Returns: The vectors with the specified tattoo.
+ * Returns: The vectors with the specified name.
  *
- * Since: 2.6
+ * Since: 2.8
  **/
 gint32
-gimp_image_get_vectors_by_tattoo (GimpImage *image,
-                                  guint      tattoo)
+gimp_image_get_vectors_by_name (GimpImage   *image,
+                                const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3444,15 +7052,15 @@ gimp_image_get_vectors_by_tattoo (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_UINT, tattoo,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-vectors-by-tattoo",
+                                                "gimp-image-get-vectors-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-tattoo",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-name",
                                             args);
   gimp_value_array_unref (args);
 
@@ -3465,148 +7073,146 @@ gimp_image_get_vectors_by_tattoo (GimpImage *image,
 }
 
 /**
- * gimp_image_get_layer_by_name:
- * @image: The image.
- * @name: The name of the layer to find.
+ * _gimp_image_get_vectors_by_name: (skip)
+ * @image_ID: The image.
+ * @name: The name of the vectors to find.
  *
- * Find a layer with a given name in an image.
+ * Find a vectors with a given name in an image.
  *
- * This procedure returns the layer with the given name in the
+ * This procedure returns the vectors with the given name in the
  * specified image.
  *
- * Returns: The layer with the specified name.
+ * Returns: The vectors with the specified name.
  *
  * Since: 2.8
  **/
 gint32
-gimp_image_get_layer_by_name (GimpImage   *image,
-                              const gchar *name)
+_gimp_image_get_vectors_by_name (gint32       image_ID,
+                                 const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gint32 vectors_ID = -1;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-layer-by-name",
+                                                "gimp-image-get-vectors-by-name",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-name",
+    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-name",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return vectors_ID;
 }
 
 /**
- * gimp_image_get_channel_by_name:
+ * gimp_image_attach_parasite:
  * @image: The image.
- * @name: The name of the channel to find.
+ * @parasite: The parasite to attach to an image.
  *
- * Find a channel with a given name in an image.
+ * Add a parasite to an image.
  *
- * This procedure returns the channel with the given name in the
- * specified image.
+ * This procedure attaches a parasite to an image. It has no return
+ * values.
  *
- * Returns: The channel with the specified name.
+ * Returns: TRUE on success.
  *
  * Since: 2.8
  **/
-gint32
-gimp_image_get_channel_by_name (GimpImage   *image,
-                                const gchar *name)
+gboolean
+gimp_image_attach_parasite (GimpImage          *image,
+                            const GimpParasite *parasite)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 channel_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-channel-by-name",
+                                                "gimp-image-attach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-name",
+    return_vals = gimp_run_procedure_array ("gimp-image-attach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return channel_ID;
+  return success;
 }
 
 /**
- * gimp_image_get_vectors_by_name:
- * @image: The image.
- * @name: The name of the vectors to find.
+ * _gimp_image_attach_parasite: (skip)
+ * @image_ID: The image.
+ * @parasite: The parasite to attach to an image.
  *
- * Find a vectors with a given name in an image.
+ * Add a parasite to an image.
  *
- * This procedure returns the vectors with the given name in the
- * specified image.
+ * This procedure attaches a parasite to an image. It has no return
+ * values.
  *
- * Returns: The vectors with the specified name.
+ * Returns: TRUE on success.
  *
  * Since: 2.8
  **/
-gint32
-gimp_image_get_vectors_by_name (GimpImage   *image,
-                                const gchar *name)
+gboolean
+_gimp_image_attach_parasite (gint32              image_ID,
+                             const GimpParasite *parasite)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 vectors_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-vectors-by-name",
+                                                "gimp-image-attach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-name",
+    return_vals = gimp_run_procedure_array ("gimp-image-attach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return vectors_ID;
+  return success;
 }
 
 /**
- * gimp_image_attach_parasite:
+ * gimp_image_detach_parasite:
  * @image: The image.
- * @parasite: The parasite to attach to an image.
+ * @name: The name of the parasite to detach from an image.
  *
- * Add a parasite to an image.
+ * Removes a parasite from an image.
  *
- * This procedure attaches a parasite to an image. It has no return
+ * This procedure detaches a parasite from an image. It has no return
  * values.
  *
  * Returns: TRUE on success.
@@ -3614,8 +7220,8 @@ gimp_image_get_vectors_by_name (GimpImage   *image,
  * Since: 2.8
  **/
 gboolean
-gimp_image_attach_parasite (GimpImage          *image,
-                            const GimpParasite *parasite)
+gimp_image_detach_parasite (GimpImage   *image,
+                            const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3624,15 +7230,15 @@ gimp_image_attach_parasite (GimpImage          *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_PARASITE, parasite,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-attach-parasite",
+                                                "gimp-image-detach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-image-attach-parasite",
+    return_vals = gimp_run_procedure_array ("gimp-image-detach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
@@ -3644,8 +7250,8 @@ gimp_image_attach_parasite (GimpImage          *image,
 }
 
 /**
- * gimp_image_detach_parasite:
- * @image: The image.
+ * _gimp_image_detach_parasite: (skip)
+ * @image_ID: The image.
  * @name: The name of the parasite to detach from an image.
  *
  * Removes a parasite from an image.
@@ -3658,8 +7264,8 @@ gimp_image_attach_parasite (GimpImage          *image,
  * Since: 2.8
  **/
 gboolean
-gimp_image_detach_parasite (GimpImage   *image,
-                            const gchar *name)
+_gimp_image_detach_parasite (gint32       image_ID,
+                             const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3667,7 +7273,7 @@ gimp_image_detach_parasite (GimpImage   *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
@@ -3732,6 +7338,51 @@ gimp_image_get_parasite (GimpImage   *image,
   return parasite;
 }
 
+/**
+ * _gimp_image_get_parasite: (skip)
+ * @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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpParasite *parasite = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-parasite",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-parasite",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    parasite = g_value_dup_boxed (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return parasite;
+}
+
 /**
  * gimp_image_get_parasite_list:
  * @image: The image.
@@ -3781,3 +7432,53 @@ gimp_image_get_parasite_list (GimpImage *image,
 
   return parasites;
 }
+
+/**
+ * _gimp_image_get_parasite_list: (skip)
+ * @image_ID: The image.
+ * @num_parasites: (out): The number of attached parasites.
+ *
+ * List all parasites.
+ *
+ * Returns a list of all currently attached parasites.
+ *
+ * Returns: (array length=num_parasites):
+ *          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)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar **parasites = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-parasite-list",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-parasite-list",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_parasites = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_parasites = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      parasites = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return parasites;
+}
diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h
index b7ad5ea4e6..c6a59a1aea 100644
--- a/libgimp/gimpimage_pdb.h
+++ b/libgimp/gimpimage_pdb.h
@@ -32,165 +32,404 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean                 gimp_image_is_valid                   (GimpImage           *image);
-gint*                    gimp_image_list                       (gint                *num_images);
-GimpImage*               gimp_image_new                        (gint                 width,
-                                                                gint                 height,
-                                                                GimpImageBaseType    type);
-GimpImage*               gimp_image_new_with_precision         (gint                 width,
-                                                                gint                 height,
-                                                                GimpImageBaseType    type,
-                                                                GimpPrecision        precision);
-GimpImage*               gimp_image_duplicate                  (GimpImage           *image);
-gboolean                 gimp_image_delete                     (GimpImage           *image);
-GimpImageBaseType        gimp_image_base_type                  (GimpImage           *image);
-GimpPrecision            gimp_image_get_precision              (GimpImage           *image);
-GimpLayerMode            gimp_image_get_default_new_layer_mode (GimpImage           *image);
-gint                     gimp_image_width                      (GimpImage           *image);
-gint                     gimp_image_height                     (GimpImage           *image);
-gint*                    gimp_image_get_layers                 (GimpImage           *image,
-                                                                gint                *num_layers);
-gint*                    gimp_image_get_channels               (GimpImage           *image,
-                                                                gint                *num_channels);
-gint*                    gimp_image_get_vectors                (GimpImage           *image,
-                                                                gint                *num_vectors);
-gint32                   gimp_image_get_active_drawable        (GimpImage           *image);
-gboolean                 gimp_image_unset_active_channel       (GimpImage           *image);
-gint32                   gimp_image_get_floating_sel           (GimpImage           *image);
-gint32                   gimp_image_floating_sel_attached_to   (GimpImage           *image);
-gboolean                 gimp_image_pick_color                 (GimpImage           *image,
-                                                                gint32               drawable_ID,
-                                                                gdouble              x,
-                                                                gdouble              y,
-                                                                gboolean             sample_merged,
-                                                                gboolean             sample_average,
-                                                                gdouble              average_radius,
-                                                                GimpRGB             *color);
-gint32                   gimp_image_pick_correlate_layer       (GimpImage           *image,
-                                                                gint                 x,
-                                                                gint                 y);
-gboolean                 gimp_image_insert_layer               (GimpImage           *image,
-                                                                gint32               layer_ID,
-                                                                gint32               parent_ID,
-                                                                gint                 position);
-gboolean                 gimp_image_remove_layer               (GimpImage           *image,
-                                                                gint32               layer_ID);
-gboolean                 gimp_image_freeze_layers              (GimpImage           *image);
-gboolean                 gimp_image_thaw_layers                (GimpImage           *image);
-gboolean                 gimp_image_insert_channel             (GimpImage           *image,
-                                                                gint32               channel_ID,
-                                                                gint32               parent_ID,
-                                                                gint                 position);
-gboolean                 gimp_image_remove_channel             (GimpImage           *image,
-                                                                gint32               channel_ID);
-gboolean                 gimp_image_freeze_channels            (GimpImage           *image);
-gboolean                 gimp_image_thaw_channels              (GimpImage           *image);
-gboolean                 gimp_image_insert_vectors             (GimpImage           *image,
-                                                                gint32               vectors_ID,
-                                                                gint32               parent_ID,
-                                                                gint                 position);
-gboolean                 gimp_image_remove_vectors             (GimpImage           *image,
-                                                                gint32               vectors_ID);
-gboolean                 gimp_image_freeze_vectors             (GimpImage           *image);
-gboolean                 gimp_image_thaw_vectors               (GimpImage           *image);
-gint                     gimp_image_get_item_position          (GimpImage           *image,
-                                                                gint32               item_ID);
-gboolean                 gimp_image_raise_item                 (GimpImage           *image,
-                                                                gint32               item_ID);
-gboolean                 gimp_image_lower_item                 (GimpImage           *image,
-                                                                gint32               item_ID);
-gboolean                 gimp_image_raise_item_to_top          (GimpImage           *image,
-                                                                gint32               item_ID);
-gboolean                 gimp_image_lower_item_to_bottom       (GimpImage           *image,
-                                                                gint32               item_ID);
-gboolean                 gimp_image_reorder_item               (GimpImage           *image,
-                                                                gint32               item_ID,
-                                                                gint32               parent_ID,
-                                                                gint                 position);
-gint32                   gimp_image_flatten                    (GimpImage           *image);
-gint32                   gimp_image_merge_visible_layers       (GimpImage           *image,
-                                                                GimpMergeType        merge_type);
-gint32                   gimp_image_merge_down                 (GimpImage           *image,
-                                                                gint32               merge_layer_ID,
-                                                                GimpMergeType        merge_type);
-G_GNUC_INTERNAL guint8*  _gimp_image_get_colormap              (GimpImage           *image,
-                                                                gint                *num_bytes);
-G_GNUC_INTERNAL gboolean _gimp_image_set_colormap              (GimpImage           *image,
-                                                                gint                 num_bytes,
-                                                                const guint8        *colormap);
-G_GNUC_INTERNAL gchar*   _gimp_image_get_metadata              (GimpImage           *image);
-G_GNUC_INTERNAL gboolean _gimp_image_set_metadata              (GimpImage           *image,
-                                                                const gchar         *metadata_string);
-gboolean                 gimp_image_clean_all                  (GimpImage           *image);
-gboolean                 gimp_image_is_dirty                   (GimpImage           *image);
-G_GNUC_INTERNAL gboolean _gimp_image_thumbnail                 (GimpImage           *image,
-                                                                gint                 width,
-                                                                gint                 height,
-                                                                gint                *actual_width,
-                                                                gint                *actual_height,
-                                                                gint                *bpp,
-                                                                gint                *thumbnail_data_count,
-                                                                guint8             **thumbnail_data);
-gint32                   gimp_image_get_active_layer           (GimpImage           *image);
-gboolean                 gimp_image_set_active_layer           (GimpImage           *image,
-                                                                gint32               active_layer_ID);
-gint32                   gimp_image_get_active_channel         (GimpImage           *image);
-gboolean                 gimp_image_set_active_channel         (GimpImage           *image,
-                                                                gint32               active_channel_ID);
-gint32                   gimp_image_get_active_vectors         (GimpImage           *image);
-gboolean                 gimp_image_set_active_vectors         (GimpImage           *image,
-                                                                gint32               active_vectors_ID);
-gint32                   gimp_image_get_selection              (GimpImage           *image);
-gboolean                 gimp_image_get_component_active       (GimpImage           *image,
-                                                                GimpChannelType      component);
-gboolean                 gimp_image_set_component_active       (GimpImage           *image,
-                                                                GimpChannelType      component,
-                                                                gboolean             active);
-gboolean                 gimp_image_get_component_visible      (GimpImage           *image,
-                                                                GimpChannelType      component);
-gboolean                 gimp_image_set_component_visible      (GimpImage           *image,
-                                                                GimpChannelType      component,
-                                                                gboolean             visible);
-gchar*                   gimp_image_get_filename               (GimpImage           *image);
-gboolean                 gimp_image_set_filename               (GimpImage           *image,
-                                                                const gchar         *filename);
-gchar*                   gimp_image_get_uri                    (GimpImage           *image);
-gchar*                   gimp_image_get_xcf_uri                (GimpImage           *image);
-gchar*                   gimp_image_get_imported_uri           (GimpImage           *image);
-gchar*                   gimp_image_get_exported_uri           (GimpImage           *image);
-gchar*                   gimp_image_get_name                   (GimpImage           *image);
-gboolean                 gimp_image_get_resolution             (GimpImage           *image,
-                                                                gdouble             *xresolution,
-                                                                gdouble             *yresolution);
-gboolean                 gimp_image_set_resolution             (GimpImage           *image,
-                                                                gdouble              xresolution,
-                                                                gdouble              yresolution);
-GimpUnit                 gimp_image_get_unit                   (GimpImage           *image);
-gboolean                 gimp_image_set_unit                   (GimpImage           *image,
-                                                                GimpUnit             unit);
-guint                    gimp_image_get_tattoo_state           (GimpImage           *image);
-gboolean                 gimp_image_set_tattoo_state           (GimpImage           *image,
-                                                                guint                tattoo_state);
-gint32                   gimp_image_get_layer_by_tattoo        (GimpImage           *image,
-                                                                guint                tattoo);
-gint32                   gimp_image_get_channel_by_tattoo      (GimpImage           *image,
-                                                                guint                tattoo);
-gint32                   gimp_image_get_vectors_by_tattoo      (GimpImage           *image,
-                                                                guint                tattoo);
-gint32                   gimp_image_get_layer_by_name          (GimpImage           *image,
-                                                                const gchar         *name);
-gint32                   gimp_image_get_channel_by_name        (GimpImage           *image,
-                                                                const gchar         *name);
-gint32                   gimp_image_get_vectors_by_name        (GimpImage           *image,
-                                                                const gchar         *name);
-gboolean                 gimp_image_attach_parasite            (GimpImage           *image,
-                                                                const GimpParasite  *parasite);
-gboolean                 gimp_image_detach_parasite            (GimpImage           *image,
-                                                                const gchar         *name);
-GimpParasite*            gimp_image_get_parasite               (GimpImage           *image,
-                                                                const gchar         *name);
-gchar**                  gimp_image_get_parasite_list          (GimpImage           *image,
-                                                                gint                *num_parasites);
+gboolean                          gimp_image_is_valid                    (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_is_valid)
+G_GNUC_INTERNAL gboolean          _gimp_image_is_valid                   (gint32               image_ID);
+gint*                             gimp_image_list                        (gint                *num_images);
+GimpImage*                        gimp_image_new                         (gint                 width,
+                                                                          gint                 height,
+                                                                          GimpImageBaseType    type);
+GIMP_DEPRECATED_FOR(gimp_image_new)
+G_GNUC_INTERNAL gint32            _gimp_image_new                        (gint                 width,
+                                                                          gint                 height,
+                                                                          GimpImageBaseType    type);
+GimpImage*                        gimp_image_new_with_precision          (gint                 width,
+                                                                          gint                 height,
+                                                                          GimpImageBaseType    type,
+                                                                          GimpPrecision        precision);
+GIMP_DEPRECATED_FOR(gimp_image_new_with_precision)
+G_GNUC_INTERNAL gint32            _gimp_image_new_with_precision         (gint                 width,
+                                                                          gint                 height,
+                                                                          GimpImageBaseType    type,
+                                                                          GimpPrecision        precision);
+GimpImage*                        gimp_image_duplicate                   (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_duplicate)
+G_GNUC_INTERNAL gint32            _gimp_image_duplicate                  (gint32               image_ID);
+gboolean                          gimp_image_delete                      (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_delete)
+G_GNUC_INTERNAL gboolean          _gimp_image_delete                     (gint32               image_ID);
+GimpImageBaseType                 gimp_image_base_type                   (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_base_type)
+G_GNUC_INTERNAL GimpImageBaseType _gimp_image_base_type                  (gint32               image_ID);
+GimpPrecision                     gimp_image_get_precision               (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_precision)
+G_GNUC_INTERNAL GimpPrecision     _gimp_image_get_precision              (gint32               image_ID);
+GimpLayerMode                     gimp_image_get_default_new_layer_mode  (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_default_new_layer_mode)
+G_GNUC_INTERNAL GimpLayerMode     _gimp_image_get_default_new_layer_mode (gint32               image_ID);
+gint                              gimp_image_width                       (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_width)
+G_GNUC_INTERNAL gint              _gimp_image_width                      (gint32               image_ID);
+gint                              gimp_image_height                      (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_height)
+G_GNUC_INTERNAL gint              _gimp_image_height                     (gint32               image_ID);
+gint*                             gimp_image_get_layers                  (GimpImage           *image,
+                                                                          gint                *num_layers);
+GIMP_DEPRECATED_FOR(gimp_image_get_layers)
+G_GNUC_INTERNAL gint*             _gimp_image_get_layers                 (gint32               image_ID,
+                                                                          gint                *num_layers);
+gint*                             gimp_image_get_channels                (GimpImage           *image,
+                                                                          gint                *num_channels);
+GIMP_DEPRECATED_FOR(gimp_image_get_channels)
+G_GNUC_INTERNAL gint*             _gimp_image_get_channels               (gint32               image_ID,
+                                                                          gint                *num_channels);
+gint*                             gimp_image_get_vectors                 (GimpImage           *image,
+                                                                          gint                *num_vectors);
+GIMP_DEPRECATED_FOR(gimp_image_get_vectors)
+G_GNUC_INTERNAL gint*             _gimp_image_get_vectors                (gint32               image_ID,
+                                                                          gint                *num_vectors);
+gint32                            gimp_image_get_active_drawable         (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_active_drawable)
+G_GNUC_INTERNAL gint32            _gimp_image_get_active_drawable        (gint32               image_ID);
+gboolean                          gimp_image_unset_active_channel        (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_unset_active_channel)
+G_GNUC_INTERNAL gboolean          _gimp_image_unset_active_channel       (gint32               image_ID);
+gint32                            gimp_image_get_floating_sel            (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_floating_sel)
+G_GNUC_INTERNAL gint32            _gimp_image_get_floating_sel           (gint32               image_ID);
+gint32                            gimp_image_floating_sel_attached_to    (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_floating_sel_attached_to)
+G_GNUC_INTERNAL gint32            _gimp_image_floating_sel_attached_to   (gint32               image_ID);
+gboolean                          gimp_image_pick_color                  (GimpImage           *image,
+                                                                          gint32               drawable_ID,
+                                                                          gdouble              x,
+                                                                          gdouble              y,
+                                                                          gboolean             sample_merged,
+                                                                          gboolean             
sample_average,
+                                                                          gdouble              
average_radius,
+                                                                          GimpRGB             *color);
+GIMP_DEPRECATED_FOR(gimp_image_pick_color)
+G_GNUC_INTERNAL 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);
+gint32                            gimp_image_pick_correlate_layer        (GimpImage           *image,
+                                                                          gint                 x,
+                                                                          gint                 y);
+GIMP_DEPRECATED_FOR(gimp_image_pick_correlate_layer)
+G_GNUC_INTERNAL gint32            _gimp_image_pick_correlate_layer       (gint32               image_ID,
+                                                                          gint                 x,
+                                                                          gint                 y);
+gboolean                          gimp_image_insert_layer                (GimpImage           *image,
+                                                                          gint32               layer_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+GIMP_DEPRECATED_FOR(gimp_image_insert_layer)
+G_GNUC_INTERNAL gboolean          _gimp_image_insert_layer               (gint32               image_ID,
+                                                                          gint32               layer_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+gboolean                          gimp_image_remove_layer                (GimpImage           *image,
+                                                                          gint32               layer_ID);
+GIMP_DEPRECATED_FOR(gimp_image_remove_layer)
+G_GNUC_INTERNAL gboolean          _gimp_image_remove_layer               (gint32               image_ID,
+                                                                          gint32               layer_ID);
+gboolean                          gimp_image_freeze_layers               (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_freeze_layers)
+G_GNUC_INTERNAL gboolean          _gimp_image_freeze_layers              (gint32               image_ID);
+gboolean                          gimp_image_thaw_layers                 (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_thaw_layers)
+G_GNUC_INTERNAL gboolean          _gimp_image_thaw_layers                (gint32               image_ID);
+gboolean                          gimp_image_insert_channel              (GimpImage           *image,
+                                                                          gint32               channel_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+GIMP_DEPRECATED_FOR(gimp_image_insert_channel)
+G_GNUC_INTERNAL gboolean          _gimp_image_insert_channel             (gint32               image_ID,
+                                                                          gint32               channel_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+gboolean                          gimp_image_remove_channel              (GimpImage           *image,
+                                                                          gint32               channel_ID);
+GIMP_DEPRECATED_FOR(gimp_image_remove_channel)
+G_GNUC_INTERNAL gboolean          _gimp_image_remove_channel             (gint32               image_ID,
+                                                                          gint32               channel_ID);
+gboolean                          gimp_image_freeze_channels             (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_freeze_channels)
+G_GNUC_INTERNAL gboolean          _gimp_image_freeze_channels            (gint32               image_ID);
+gboolean                          gimp_image_thaw_channels               (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_thaw_channels)
+G_GNUC_INTERNAL gboolean          _gimp_image_thaw_channels              (gint32               image_ID);
+gboolean                          gimp_image_insert_vectors              (GimpImage           *image,
+                                                                          gint32               vectors_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+GIMP_DEPRECATED_FOR(gimp_image_insert_vectors)
+G_GNUC_INTERNAL gboolean          _gimp_image_insert_vectors             (gint32               image_ID,
+                                                                          gint32               vectors_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+gboolean                          gimp_image_remove_vectors              (GimpImage           *image,
+                                                                          gint32               vectors_ID);
+GIMP_DEPRECATED_FOR(gimp_image_remove_vectors)
+G_GNUC_INTERNAL gboolean          _gimp_image_remove_vectors             (gint32               image_ID,
+                                                                          gint32               vectors_ID);
+gboolean                          gimp_image_freeze_vectors              (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_freeze_vectors)
+G_GNUC_INTERNAL gboolean          _gimp_image_freeze_vectors             (gint32               image_ID);
+gboolean                          gimp_image_thaw_vectors                (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_thaw_vectors)
+G_GNUC_INTERNAL gboolean          _gimp_image_thaw_vectors               (gint32               image_ID);
+gint                              gimp_image_get_item_position           (GimpImage           *image,
+                                                                          gint32               item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_get_item_position)
+G_GNUC_INTERNAL gint              _gimp_image_get_item_position          (gint32               image_ID,
+                                                                          gint32               item_ID);
+gboolean                          gimp_image_raise_item                  (GimpImage           *image,
+                                                                          gint32               item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_raise_item)
+G_GNUC_INTERNAL gboolean          _gimp_image_raise_item                 (gint32               image_ID,
+                                                                          gint32               item_ID);
+gboolean                          gimp_image_lower_item                  (GimpImage           *image,
+                                                                          gint32               item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_lower_item)
+G_GNUC_INTERNAL gboolean          _gimp_image_lower_item                 (gint32               image_ID,
+                                                                          gint32               item_ID);
+gboolean                          gimp_image_raise_item_to_top           (GimpImage           *image,
+                                                                          gint32               item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_raise_item_to_top)
+G_GNUC_INTERNAL gboolean          _gimp_image_raise_item_to_top          (gint32               image_ID,
+                                                                          gint32               item_ID);
+gboolean                          gimp_image_lower_item_to_bottom        (GimpImage           *image,
+                                                                          gint32               item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_lower_item_to_bottom)
+G_GNUC_INTERNAL gboolean          _gimp_image_lower_item_to_bottom       (gint32               image_ID,
+                                                                          gint32               item_ID);
+gboolean                          gimp_image_reorder_item                (GimpImage           *image,
+                                                                          gint32               item_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+GIMP_DEPRECATED_FOR(gimp_image_reorder_item)
+G_GNUC_INTERNAL gboolean          _gimp_image_reorder_item               (gint32               image_ID,
+                                                                          gint32               item_ID,
+                                                                          gint32               parent_ID,
+                                                                          gint                 position);
+gint32                            gimp_image_flatten                     (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_flatten)
+G_GNUC_INTERNAL gint32            _gimp_image_flatten                    (gint32               image_ID);
+gint32                            gimp_image_merge_visible_layers        (GimpImage           *image,
+                                                                          GimpMergeType        merge_type);
+GIMP_DEPRECATED_FOR(gimp_image_merge_visible_layers)
+G_GNUC_INTERNAL gint32            _gimp_image_merge_visible_layers       (gint32               image_ID,
+                                                                          GimpMergeType        merge_type);
+gint32                            gimp_image_merge_down                  (GimpImage           *image,
+                                                                          gint32               
merge_layer_ID,
+                                                                          GimpMergeType        merge_type);
+GIMP_DEPRECATED_FOR(gimp_image_merge_down)
+G_GNUC_INTERNAL gint32            _gimp_image_merge_down                 (gint32               image_ID,
+                                                                          gint32               
merge_layer_ID,
+                                                                          GimpMergeType        merge_type);
+G_GNUC_INTERNAL guint8*           _gimp_image_get_colormap               (GimpImage           *image,
+                                                                          gint                *num_bytes);
+GIMP_DEPRECATED_FOR(_gimp_image_get_colormap)
+G_GNUC_INTERNAL guint8*           __gimp_image_get_colormap              (gint32               image_ID,
+                                                                          gint                *num_bytes);
+G_GNUC_INTERNAL gboolean          _gimp_image_set_colormap               (GimpImage           *image,
+                                                                          gint                 num_bytes,
+                                                                          const guint8        *colormap);
+GIMP_DEPRECATED_FOR(_gimp_image_set_colormap)
+G_GNUC_INTERNAL gboolean          __gimp_image_set_colormap              (gint32               image_ID,
+                                                                          gint                 num_bytes,
+                                                                          const guint8        *colormap);
+G_GNUC_INTERNAL gchar*            _gimp_image_get_metadata               (GimpImage           *image);
+GIMP_DEPRECATED_FOR(_gimp_image_get_metadata)
+G_GNUC_INTERNAL gchar*            __gimp_image_get_metadata              (gint32               image_ID);
+G_GNUC_INTERNAL gboolean          _gimp_image_set_metadata               (GimpImage           *image,
+                                                                          const gchar         
*metadata_string);
+GIMP_DEPRECATED_FOR(_gimp_image_set_metadata)
+G_GNUC_INTERNAL gboolean          __gimp_image_set_metadata              (gint32               image_ID,
+                                                                          const gchar         
*metadata_string);
+gboolean                          gimp_image_clean_all                   (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_clean_all)
+G_GNUC_INTERNAL gboolean          _gimp_image_clean_all                  (gint32               image_ID);
+gboolean                          gimp_image_is_dirty                    (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_is_dirty)
+G_GNUC_INTERNAL gboolean          _gimp_image_is_dirty                   (gint32               image_ID);
+G_GNUC_INTERNAL gboolean          _gimp_image_thumbnail                  (GimpImage           *image,
+                                                                          gint                 width,
+                                                                          gint                 height,
+                                                                          gint                *actual_width,
+                                                                          gint                *actual_height,
+                                                                          gint                *bpp,
+                                                                          gint                
*thumbnail_data_count,
+                                                                          guint8             
**thumbnail_data);
+GIMP_DEPRECATED_FOR(_gimp_image_thumbnail)
+G_GNUC_INTERNAL 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);
+gint32                            gimp_image_get_active_layer            (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_active_layer)
+G_GNUC_INTERNAL gint32            _gimp_image_get_active_layer           (gint32               image_ID);
+gboolean                          gimp_image_set_active_layer            (GimpImage           *image,
+                                                                          gint32               
active_layer_ID);
+GIMP_DEPRECATED_FOR(gimp_image_set_active_layer)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_active_layer           (gint32               image_ID,
+                                                                          gint32               
active_layer_ID);
+gint32                            gimp_image_get_active_channel          (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_active_channel)
+G_GNUC_INTERNAL gint32            _gimp_image_get_active_channel         (gint32               image_ID);
+gboolean                          gimp_image_set_active_channel          (GimpImage           *image,
+                                                                          gint32               
active_channel_ID);
+GIMP_DEPRECATED_FOR(gimp_image_set_active_channel)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_active_channel         (gint32               image_ID,
+                                                                          gint32               
active_channel_ID);
+gint32                            gimp_image_get_active_vectors          (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_active_vectors)
+G_GNUC_INTERNAL gint32            _gimp_image_get_active_vectors         (gint32               image_ID);
+gboolean                          gimp_image_set_active_vectors          (GimpImage           *image,
+                                                                          gint32               
active_vectors_ID);
+GIMP_DEPRECATED_FOR(gimp_image_set_active_vectors)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_active_vectors         (gint32               image_ID,
+                                                                          gint32               
active_vectors_ID);
+gint32                            gimp_image_get_selection               (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_selection)
+G_GNUC_INTERNAL gint32            _gimp_image_get_selection              (gint32               image_ID);
+gboolean                          gimp_image_get_component_active        (GimpImage           *image,
+                                                                          GimpChannelType      component);
+GIMP_DEPRECATED_FOR(gimp_image_get_component_active)
+G_GNUC_INTERNAL gboolean          _gimp_image_get_component_active       (gint32               image_ID,
+                                                                          GimpChannelType      component);
+gboolean                          gimp_image_set_component_active        (GimpImage           *image,
+                                                                          GimpChannelType      component,
+                                                                          gboolean             active);
+GIMP_DEPRECATED_FOR(gimp_image_set_component_active)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_component_active       (gint32               image_ID,
+                                                                          GimpChannelType      component,
+                                                                          gboolean             active);
+gboolean                          gimp_image_get_component_visible       (GimpImage           *image,
+                                                                          GimpChannelType      component);
+GIMP_DEPRECATED_FOR(gimp_image_get_component_visible)
+G_GNUC_INTERNAL gboolean          _gimp_image_get_component_visible      (gint32               image_ID,
+                                                                          GimpChannelType      component);
+gboolean                          gimp_image_set_component_visible       (GimpImage           *image,
+                                                                          GimpChannelType      component,
+                                                                          gboolean             visible);
+GIMP_DEPRECATED_FOR(gimp_image_set_component_visible)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_component_visible      (gint32               image_ID,
+                                                                          GimpChannelType      component,
+                                                                          gboolean             visible);
+gchar*                            gimp_image_get_filename                (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_filename)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_filename               (gint32               image_ID);
+gboolean                          gimp_image_set_filename                (GimpImage           *image,
+                                                                          const gchar         *filename);
+GIMP_DEPRECATED_FOR(gimp_image_set_filename)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_filename               (gint32               image_ID,
+                                                                          const gchar         *filename);
+gchar*                            gimp_image_get_uri                     (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_uri)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_uri                    (gint32               image_ID);
+gchar*                            gimp_image_get_xcf_uri                 (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_xcf_uri)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_xcf_uri                (gint32               image_ID);
+gchar*                            gimp_image_get_imported_uri            (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_imported_uri)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_imported_uri           (gint32               image_ID);
+gchar*                            gimp_image_get_exported_uri            (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_exported_uri)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_exported_uri           (gint32               image_ID);
+gchar*                            gimp_image_get_name                    (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_name)
+G_GNUC_INTERNAL gchar*            _gimp_image_get_name                   (gint32               image_ID);
+gboolean                          gimp_image_get_resolution              (GimpImage           *image,
+                                                                          gdouble             *xresolution,
+                                                                          gdouble             *yresolution);
+GIMP_DEPRECATED_FOR(gimp_image_get_resolution)
+G_GNUC_INTERNAL gboolean          _gimp_image_get_resolution             (gint32               image_ID,
+                                                                          gdouble             *xresolution,
+                                                                          gdouble             *yresolution);
+gboolean                          gimp_image_set_resolution              (GimpImage           *image,
+                                                                          gdouble              xresolution,
+                                                                          gdouble              yresolution);
+GIMP_DEPRECATED_FOR(gimp_image_set_resolution)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_resolution             (gint32               image_ID,
+                                                                          gdouble              xresolution,
+                                                                          gdouble              yresolution);
+GimpUnit                          gimp_image_get_unit                    (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_unit)
+G_GNUC_INTERNAL GimpUnit          _gimp_image_get_unit                   (gint32               image_ID);
+gboolean                          gimp_image_set_unit                    (GimpImage           *image,
+                                                                          GimpUnit             unit);
+GIMP_DEPRECATED_FOR(gimp_image_set_unit)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_unit                   (gint32               image_ID,
+                                                                          GimpUnit             unit);
+guint                             gimp_image_get_tattoo_state            (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_get_tattoo_state)
+G_GNUC_INTERNAL guint             _gimp_image_get_tattoo_state           (gint32               image_ID);
+gboolean                          gimp_image_set_tattoo_state            (GimpImage           *image,
+                                                                          guint                tattoo_state);
+GIMP_DEPRECATED_FOR(gimp_image_set_tattoo_state)
+G_GNUC_INTERNAL gboolean          _gimp_image_set_tattoo_state           (gint32               image_ID,
+                                                                          guint                tattoo_state);
+gint32                            gimp_image_get_layer_by_tattoo         (GimpImage           *image,
+                                                                          guint                tattoo);
+GIMP_DEPRECATED_FOR(gimp_image_get_layer_by_tattoo)
+G_GNUC_INTERNAL gint32            _gimp_image_get_layer_by_tattoo        (gint32               image_ID,
+                                                                          guint                tattoo);
+gint32                            gimp_image_get_channel_by_tattoo       (GimpImage           *image,
+                                                                          guint                tattoo);
+GIMP_DEPRECATED_FOR(gimp_image_get_channel_by_tattoo)
+G_GNUC_INTERNAL gint32            _gimp_image_get_channel_by_tattoo      (gint32               image_ID,
+                                                                          guint                tattoo);
+gint32                            gimp_image_get_vectors_by_tattoo       (GimpImage           *image,
+                                                                          guint                tattoo);
+GIMP_DEPRECATED_FOR(gimp_image_get_vectors_by_tattoo)
+G_GNUC_INTERNAL gint32            _gimp_image_get_vectors_by_tattoo      (gint32               image_ID,
+                                                                          guint                tattoo);
+gint32                            gimp_image_get_layer_by_name           (GimpImage           *image,
+                                                                          const gchar         *name);
+GIMP_DEPRECATED_FOR(gimp_image_get_layer_by_name)
+G_GNUC_INTERNAL gint32            _gimp_image_get_layer_by_name          (gint32               image_ID,
+                                                                          const gchar         *name);
+gint32                            gimp_image_get_channel_by_name         (GimpImage           *image,
+                                                                          const gchar         *name);
+GIMP_DEPRECATED_FOR(gimp_image_get_channel_by_name)
+G_GNUC_INTERNAL gint32            _gimp_image_get_channel_by_name        (gint32               image_ID,
+                                                                          const gchar         *name);
+gint32                            gimp_image_get_vectors_by_name         (GimpImage           *image,
+                                                                          const gchar         *name);
+GIMP_DEPRECATED_FOR(gimp_image_get_vectors_by_name)
+G_GNUC_INTERNAL gint32            _gimp_image_get_vectors_by_name        (gint32               image_ID,
+                                                                          const gchar         *name);
+gboolean                          gimp_image_attach_parasite             (GimpImage           *image,
+                                                                          const GimpParasite  *parasite);
+GIMP_DEPRECATED_FOR(gimp_image_attach_parasite)
+G_GNUC_INTERNAL gboolean          _gimp_image_attach_parasite            (gint32               image_ID,
+                                                                          const GimpParasite  *parasite);
+gboolean                          gimp_image_detach_parasite             (GimpImage           *image,
+                                                                          const gchar         *name);
+GIMP_DEPRECATED_FOR(gimp_image_detach_parasite)
+G_GNUC_INTERNAL gboolean          _gimp_image_detach_parasite            (gint32               image_ID,
+                                                                          const gchar         *name);
+GimpParasite*                     gimp_image_get_parasite                (GimpImage           *image,
+                                                                          const gchar         *name);
+GIMP_DEPRECATED_FOR(gimp_image_get_parasite)
+G_GNUC_INTERNAL GimpParasite*     _gimp_image_get_parasite               (gint32               image_ID,
+                                                                          const gchar         *name);
+gchar**                           gimp_image_get_parasite_list           (GimpImage           *image,
+                                                                          gint                
*num_parasites);
+GIMP_DEPRECATED_FOR(gimp_image_get_parasite_list)
+G_GNUC_INTERNAL gchar**           _gimp_image_get_parasite_list          (gint32               image_ID,
+                                                                          gint                
*num_parasites);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index 170972c7ba..921cac6cc2 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -85,6 +85,56 @@ _gimp_image_get_color_profile (GimpImage *image,
   return profile_data;
 }
 
+/**
+ * __gimp_image_get_color_profile: (skip)
+ * @image_ID: The image.
+ * @num_bytes: (out): Number of bytes in the color_profile array.
+ *
+ * Returns the image's color profile
+ *
+ * This procedure returns the image's color profile, or NULL if the
+ * image has no color profile assigned.
+ *
+ * Returns: (array length=num_bytes): The image's serialized color profile.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.10
+ **/
+guint8 *
+__gimp_image_get_color_profile (gint32  image_ID,
+                                gint   *num_bytes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  guint8 *profile_data = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-color-profile",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-color-profile",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_bytes = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return profile_data;
+}
+
 /**
  * _gimp_image_get_effective_color_profile:
  * @image: The image.
@@ -139,6 +189,59 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
   return profile_data;
 }
 
+/**
+ * __gimp_image_get_effective_color_profile: (skip)
+ * @image_ID: The image.
+ * @num_bytes: (out): Number of bytes in the color_profile array.
+ *
+ * Returns the color profile that is used for the image
+ *
+ * This procedure returns the color profile that is actually used for
+ * this image, which is the profile returned by
+ * gimp_image_get_color_profile() if the image has a profile assigned,
+ * or a generated default RGB or grayscale profile, according to the
+ * image's type.
+ *
+ * Returns: (array length=num_bytes): The image's serialized color profile.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.10
+ **/
+guint8 *
+__gimp_image_get_effective_color_profile (gint32  image_ID,
+                                          gint   *num_bytes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  guint8 *profile_data = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-effective-color-profile",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-effective-color-profile",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_bytes = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return profile_data;
+}
+
 /**
  * _gimp_image_set_color_profile:
  * @image: The image.
@@ -190,6 +293,57 @@ _gimp_image_set_color_profile (GimpImage    *image,
   return success;
 }
 
+/**
+ * __gimp_image_set_color_profile: (skip)
+ * @image_ID: The image.
+ * @num_bytes: Number of bytes in the color_profile array.
+ * @color_profile: (array length=num_bytes) (element-type guint8): The new serialized color profile.
+ *
+ * Sets the image's color profile
+ *
+ * This procedure sets the image's color profile, or unsets it if NULL
+ * is passed as 'color_profile'. This procedure does no color
+ * conversion. However, it will change the pixel format of all layers
+ * to contain the babl space matching the profile. You must call this
+ * procedure before adding layers to the image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+__gimp_image_set_color_profile (gint32        image_ID,
+                                gint          num_bytes,
+                                const guint8 *color_profile)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, num_bytes,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-color-profile",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_set_color_profile_from_file:
  * @image: The image.
@@ -238,6 +392,54 @@ gimp_image_set_color_profile_from_file (GimpImage   *image,
   return success;
 }
 
+/**
+ * _gimp_image_set_color_profile_from_file: (skip)
+ * @image_ID: The image.
+ * @uri: The URI of the file containing the new color profile.
+ *
+ * Sets the image's color profile from an ICC file
+ *
+ * This procedure sets the image's color profile from a file containing
+ * an ICC profile, or unsets it if NULL is passed as 'uri'. This
+ * procedure does no color conversion. However, it will change the
+ * pixel format of all layers to contain the babl space matching the
+ * profile. You must call this procedure before adding layers to the
+ * image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_image_set_color_profile_from_file (gint32       image_ID,
+                                         const gchar *uri)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, uri,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-set-color-profile-from-file",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile-from-file",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * _gimp_image_convert_color_profile:
  * @image: The image.
@@ -294,6 +496,62 @@ _gimp_image_convert_color_profile (GimpImage                *image,
   return success;
 }
 
+/**
+ * __gimp_image_convert_color_profile: (skip)
+ * @image_ID: The image.
+ * @num_bytes: Number of bytes in the color_profile array.
+ * @color_profile: (array length=num_bytes) (element-type guint8): The serialized color profile.
+ * @intent: Rendering intent.
+ * @bpc: Black point compensation.
+ *
+ * Convert the image's layers to a color profile
+ *
+ * This procedure converts from the image's color profile (or the
+ * default RGB or grayscale profile if none is set) to the given color
+ * profile. Only RGB and grayscale color profiles are accepted,
+ * according to the image's type.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+__gimp_image_convert_color_profile (gint32                    image_ID,
+                                    gint                      num_bytes,
+                                    const guint8             *color_profile,
+                                    GimpColorRenderingIntent  intent,
+                                    gboolean                  bpc)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, num_bytes,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
+                                          G_TYPE_BOOLEAN, bpc,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-color-profile",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_convert_color_profile_from_file:
  * @image: The image.
@@ -345,3 +603,55 @@ gimp_image_convert_color_profile_from_file (GimpImage                *image,
 
   return success;
 }
+
+/**
+ * _gimp_image_convert_color_profile_from_file: (skip)
+ * @image_ID: The image.
+ * @uri: The URI of the file containing the new color profile.
+ * @intent: Rendering intent.
+ * @bpc: Black point compensation.
+ *
+ * Convert the image's layers to a color profile
+ *
+ * This procedure converts from the image's color profile (or the
+ * default RGB or grayscale profile if none is set) to an ICC profile
+ * specified by 'uri'. Only RGB and grayscale color profiles are
+ * accepted, according to the image's type.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_image_convert_color_profile_from_file (gint32                    image_ID,
+                                             const gchar              *uri,
+                                             GimpColorRenderingIntent  intent,
+                                             gboolean                  bpc)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, uri,
+                                          GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
+                                          G_TYPE_BOOLEAN, bpc,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-color-profile-from-file",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile-from-file",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpimagecolorprofile_pdb.h b/libgimp/gimpimagecolorprofile_pdb.h
index 454a837bfe..ded795b2e4 100644
--- a/libgimp/gimpimagecolorprofile_pdb.h
+++ b/libgimp/gimpimagecolorprofile_pdb.h
@@ -32,24 +32,48 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-G_GNUC_INTERNAL guint8*  _gimp_image_get_color_profile              (GimpImage                *image,
-                                                                     gint                     *num_bytes);
-G_GNUC_INTERNAL guint8*  _gimp_image_get_effective_color_profile    (GimpImage                *image,
-                                                                     gint                     *num_bytes);
-G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile              (GimpImage                *image,
-                                                                     gint                      num_bytes,
-                                                                     const guint8             
*color_profile);
-gboolean                 gimp_image_set_color_profile_from_file     (GimpImage                *image,
-                                                                     const gchar              *uri);
-G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile          (GimpImage                *image,
-                                                                     gint                      num_bytes,
-                                                                     const guint8             *color_profile,
-                                                                     GimpColorRenderingIntent  intent,
-                                                                     gboolean                  bpc);
-gboolean                 gimp_image_convert_color_profile_from_file (GimpImage                *image,
-                                                                     const gchar              *uri,
-                                                                     GimpColorRenderingIntent  intent,
-                                                                     gboolean                  bpc);
+G_GNUC_INTERNAL guint8*  _gimp_image_get_color_profile               (GimpImage                *image,
+                                                                      gint                     *num_bytes);
+GIMP_DEPRECATED_FOR(_gimp_image_get_color_profile)
+G_GNUC_INTERNAL guint8*  __gimp_image_get_color_profile              (gint32                    image_ID,
+                                                                      gint                     *num_bytes);
+G_GNUC_INTERNAL guint8*  _gimp_image_get_effective_color_profile     (GimpImage                *image,
+                                                                      gint                     *num_bytes);
+GIMP_DEPRECATED_FOR(_gimp_image_get_effective_color_profile)
+G_GNUC_INTERNAL guint8*  __gimp_image_get_effective_color_profile    (gint32                    image_ID,
+                                                                      gint                     *num_bytes);
+G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile               (GimpImage                *image,
+                                                                      gint                      num_bytes,
+                                                                      const guint8             
*color_profile);
+GIMP_DEPRECATED_FOR(_gimp_image_set_color_profile)
+G_GNUC_INTERNAL gboolean __gimp_image_set_color_profile              (gint32                    image_ID,
+                                                                      gint                      num_bytes,
+                                                                      const guint8             
*color_profile);
+gboolean                 gimp_image_set_color_profile_from_file      (GimpImage                *image,
+                                                                      const gchar              *uri);
+GIMP_DEPRECATED_FOR(gimp_image_set_color_profile_from_file)
+G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile_from_file     (gint32                    image_ID,
+                                                                      const gchar              *uri);
+G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile           (GimpImage                *image,
+                                                                      gint                      num_bytes,
+                                                                      const guint8             
*color_profile,
+                                                                      GimpColorRenderingIntent  intent,
+                                                                      gboolean                  bpc);
+GIMP_DEPRECATED_FOR(_gimp_image_convert_color_profile)
+G_GNUC_INTERNAL gboolean __gimp_image_convert_color_profile          (gint32                    image_ID,
+                                                                      gint                      num_bytes,
+                                                                      const guint8             
*color_profile,
+                                                                      GimpColorRenderingIntent  intent,
+                                                                      gboolean                  bpc);
+gboolean                 gimp_image_convert_color_profile_from_file  (GimpImage                *image,
+                                                                      const gchar              *uri,
+                                                                      GimpColorRenderingIntent  intent,
+                                                                      gboolean                  bpc);
+GIMP_DEPRECATED_FOR(gimp_image_convert_color_profile_from_file)
+G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile_from_file (gint32                    image_ID,
+                                                                      const gchar              *uri,
+                                                                      GimpColorRenderingIntent  intent,
+                                                                      gboolean                  bpc);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c
index 2033e89c22..ed49b3ec9d 100644
--- a/libgimp/gimpimageconvert_pdb.c
+++ b/libgimp/gimpimageconvert_pdb.c
@@ -75,6 +75,47 @@ gimp_image_convert_rgb (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_convert_rgb: (skip)
+ * @image_ID: The image.
+ *
+ * Convert specified image to RGB color
+ *
+ * This procedure converts the specified image to RGB color. This
+ * process requires an image in Grayscale or Indexed color mode. No
+ * image content is lost in this process aside from the colormap for an
+ * indexed image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_convert_rgb (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-rgb",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-rgb",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_convert_grayscale:
  * @image: The image.
@@ -114,6 +155,45 @@ gimp_image_convert_grayscale (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_convert_grayscale: (skip)
+ * @image_ID: The image.
+ *
+ * Convert specified image to grayscale
+ *
+ * This procedure converts the specified image to grayscale. This
+ * process requires an image in RGB or Indexed color mode.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_convert_grayscale (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-grayscale",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-grayscale",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_convert_indexed:
  * @image: The image.
@@ -182,6 +262,74 @@ gimp_image_convert_indexed (GimpImage              *image,
   return success;
 }
 
+/**
+ * _gimp_image_convert_indexed: (skip)
+ * @image_ID: The image.
+ * @dither_type: The dither type to use.
+ * @palette_type: The type of palette to use.
+ * @num_cols: The number of colors to quantize to, ignored unless (palette_type == 
GIMP_CONVERT_PALETTE_GENERATE).
+ * @alpha_dither: Dither transparency to fake partial opacity.
+ * @remove_unused: Remove unused or duplicate color entries from final palette, ignored if (palette_type == 
GIMP_CONVERT_PALETTE_GENERATE).
+ * @palette: The name of the custom palette to use, ignored unless (palette_type == 
GIMP_CONVERT_PALETTE_CUSTOM).
+ *
+ * Convert specified image to and Indexed image
+ *
+ * This procedure converts the specified image to 'indexed' color. This
+ * process requires an image in RGB or Grayscale mode. The
+ * 'palette_type' specifies what kind of palette to use, A type of '0'
+ * means to use an optimal palette of 'num_cols' generated from the
+ * colors in the image. A type of '1' means to re-use the previous
+ * palette (not currently implemented). A type of '2' means to use the
+ * so-called WWW-optimized palette. Type '3' means to use only black
+ * and white colors. A type of '4' means to use a palette from the gimp
+ * palettes directories. The 'dither type' specifies what kind of
+ * dithering to use. '0' means no dithering, '1' means standard
+ * Floyd-Steinberg error diffusion, '2' means Floyd-Steinberg error
+ * diffusion with reduced bleeding, '3' means dithering based on pixel
+ * location ('Fixed' dithering).
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_convert_indexed (gint32                  image_ID,
+                             GimpConvertDitherType   dither_type,
+                             GimpConvertPaletteType  palette_type,
+                             gint                    num_cols,
+                             gboolean                alpha_dither,
+                             gboolean                remove_unused,
+                             const gchar            *palette)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type,
+                                          GIMP_TYPE_CONVERT_PALETTE_TYPE, palette_type,
+                                          G_TYPE_INT, num_cols,
+                                          G_TYPE_BOOLEAN, alpha_dither,
+                                          G_TYPE_BOOLEAN, remove_unused,
+                                          G_TYPE_STRING, palette,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-indexed",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-indexed",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_convert_set_dither_matrix:
  * @width: Width of the matrix (0 to reset to default matrix).
@@ -277,3 +425,48 @@ gimp_image_convert_precision (GimpImage     *image,
 
   return success;
 }
+
+/**
+ * _gimp_image_convert_precision: (skip)
+ * @image_ID: The image.
+ * @precision: The new precision.
+ *
+ * Convert the image to the specified precision
+ *
+ * This procedure converts the image to the specified precision. Note
+ * that indexed images cannot be converted and are always in
+ * GIMP_PRECISION_U8.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_image_convert_precision (gint32        image_ID,
+                               GimpPrecision precision)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_PRECISION, precision,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-convert-precision",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-convert-precision",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpimageconvert_pdb.h b/libgimp/gimpimageconvert_pdb.h
index fe4cfaf973..a319d6470d 100644
--- a/libgimp/gimpimageconvert_pdb.h
+++ b/libgimp/gimpimageconvert_pdb.h
@@ -32,21 +32,36 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_image_convert_rgb               (GimpImage              *image);
-gboolean gimp_image_convert_grayscale         (GimpImage              *image);
-gboolean gimp_image_convert_indexed           (GimpImage              *image,
-                                               GimpConvertDitherType   dither_type,
-                                               GimpConvertPaletteType  palette_type,
-                                               gint                    num_cols,
-                                               gboolean                alpha_dither,
-                                               gboolean                remove_unused,
-                                               const gchar            *palette);
-gboolean gimp_image_convert_set_dither_matrix (gint                    width,
-                                               gint                    height,
-                                               gint                    matrix_length,
-                                               const guint8           *matrix);
-gboolean gimp_image_convert_precision         (GimpImage              *image,
-                                               GimpPrecision           precision);
+gboolean                 gimp_image_convert_rgb               (GimpImage              *image);
+GIMP_DEPRECATED_FOR(gimp_image_convert_rgb)
+G_GNUC_INTERNAL gboolean _gimp_image_convert_rgb              (gint32                  image_ID);
+gboolean                 gimp_image_convert_grayscale         (GimpImage              *image);
+GIMP_DEPRECATED_FOR(gimp_image_convert_grayscale)
+G_GNUC_INTERNAL gboolean _gimp_image_convert_grayscale        (gint32                  image_ID);
+gboolean                 gimp_image_convert_indexed           (GimpImage              *image,
+                                                               GimpConvertDitherType   dither_type,
+                                                               GimpConvertPaletteType  palette_type,
+                                                               gint                    num_cols,
+                                                               gboolean                alpha_dither,
+                                                               gboolean                remove_unused,
+                                                               const gchar            *palette);
+GIMP_DEPRECATED_FOR(gimp_image_convert_indexed)
+G_GNUC_INTERNAL gboolean _gimp_image_convert_indexed          (gint32                  image_ID,
+                                                               GimpConvertDitherType   dither_type,
+                                                               GimpConvertPaletteType  palette_type,
+                                                               gint                    num_cols,
+                                                               gboolean                alpha_dither,
+                                                               gboolean                remove_unused,
+                                                               const gchar            *palette);
+gboolean                 gimp_image_convert_set_dither_matrix (gint                    width,
+                                                               gint                    height,
+                                                               gint                    matrix_length,
+                                                               const guint8           *matrix);
+gboolean                 gimp_image_convert_precision         (GimpImage              *image,
+                                                               GimpPrecision           precision);
+GIMP_DEPRECATED_FOR(gimp_image_convert_precision)
+G_GNUC_INTERNAL gboolean _gimp_image_convert_precision        (gint32                  image_ID,
+                                                               GimpPrecision           precision);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c
index e64ffa672c..78d45f333c 100644
--- a/libgimp/gimpimagegrid_pdb.c
+++ b/libgimp/gimpimagegrid_pdb.c
@@ -88,6 +88,60 @@ gimp_image_grid_get_spacing (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_get_spacing: (skip)
+ * @image_ID: The image.
+ * @xspacing: (out): The image's grid horizontal spacing.
+ * @yspacing: (out): The image's grid vertical spacing.
+ *
+ * Gets the spacing of an image's grid.
+ *
+ * This procedure retrieves the horizontal and vertical spacing of an
+ * image's grid. It takes the image as parameter.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_get_spacing (gint32   image_ID,
+                              gdouble *xspacing,
+                              gdouble *yspacing)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-get-spacing",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-get-spacing",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *xspacing = 0.0;
+  *yspacing = 0.0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *xspacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *yspacing = g_value_get_double (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_set_spacing:
  * @image: The image.
@@ -135,6 +189,53 @@ gimp_image_grid_set_spacing (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_set_spacing: (skip)
+ * @image_ID: The image.
+ * @xspacing: The image's grid horizontal spacing.
+ * @yspacing: The image's grid vertical spacing.
+ *
+ * Sets the spacing of an image's grid.
+ *
+ * This procedure sets the horizontal and vertical spacing of an
+ * image's grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_set_spacing (gint32  image_ID,
+                              gdouble xspacing,
+                              gdouble yspacing)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xspacing,
+                                          G_TYPE_DOUBLE, yspacing,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-set-spacing",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-set-spacing",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_get_offset:
  * @image: The image.
@@ -189,6 +290,60 @@ gimp_image_grid_get_offset (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_get_offset: (skip)
+ * @image_ID: The image.
+ * @xoffset: (out): The image's grid horizontal offset.
+ * @yoffset: (out): The image's grid vertical offset.
+ *
+ * Gets the offset of an image's grid.
+ *
+ * This procedure retrieves the horizontal and vertical offset of an
+ * image's grid. It takes the image as parameter.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_get_offset (gint32   image_ID,
+                             gdouble *xoffset,
+                             gdouble *yoffset)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-get-offset",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-get-offset",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *xoffset = 0.0;
+  *yoffset = 0.0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *xoffset = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *yoffset = g_value_get_double (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_set_offset:
  * @image: The image.
@@ -236,6 +391,53 @@ gimp_image_grid_set_offset (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_set_offset: (skip)
+ * @image_ID: The image.
+ * @xoffset: The image's grid horizontal offset.
+ * @yoffset: The image's grid vertical offset.
+ *
+ * Sets the offset of an image's grid.
+ *
+ * This procedure sets the horizontal and vertical offset of an image's
+ * grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_set_offset (gint32  image_ID,
+                             gdouble xoffset,
+                             gdouble yoffset)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xoffset,
+                                          G_TYPE_DOUBLE, yoffset,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-set-offset",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-set-offset",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_get_foreground_color:
  * @image: The image.
@@ -281,6 +483,51 @@ gimp_image_grid_get_foreground_color (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_get_foreground_color: (skip)
+ * @image_ID: The image.
+ * @fgcolor: (out caller-allocates): The image's grid foreground color.
+ *
+ * Sets the foreground color of an image's grid.
+ *
+ * This procedure gets the foreground color of an image's grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_get_foreground_color (gint32   image_ID,
+                                       GimpRGB *fgcolor)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-get-foreground-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-get-foreground-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*fgcolor);
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_set_foreground_color:
  * @image: The image.
@@ -324,6 +571,49 @@ gimp_image_grid_set_foreground_color (GimpImage     *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_set_foreground_color: (skip)
+ * @image_ID: The image.
+ * @fgcolor: The new foreground color.
+ *
+ * Gets the foreground color of an image's grid.
+ *
+ * This procedure sets the foreground color of an image's grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_set_foreground_color (gint32         image_ID,
+                                       const GimpRGB *fgcolor)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_RGB, fgcolor,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-set-foreground-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-set-foreground-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_get_background_color:
  * @image: The image.
@@ -369,6 +659,51 @@ gimp_image_grid_get_background_color (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_get_background_color: (skip)
+ * @image_ID: The image.
+ * @bgcolor: (out caller-allocates): The image's grid background color.
+ *
+ * Sets the background color of an image's grid.
+ *
+ * This procedure gets the background color of an image's grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_get_background_color (gint32   image_ID,
+                                       GimpRGB *bgcolor)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-get-background-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-get-background-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*bgcolor);
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_set_background_color:
  * @image: The image.
@@ -412,6 +747,49 @@ gimp_image_grid_set_background_color (GimpImage     *image,
   return success;
 }
 
+/**
+ * _gimp_image_grid_set_background_color: (skip)
+ * @image_ID: The image.
+ * @bgcolor: The new background color.
+ *
+ * Gets the background color of an image's grid.
+ *
+ * This procedure sets the background color of an image's grid.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_set_background_color (gint32         image_ID,
+                                       const GimpRGB *bgcolor)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_RGB, bgcolor,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-set-background-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-set-background-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_grid_get_style:
  * @image: The image.
@@ -453,6 +831,47 @@ gimp_image_grid_get_style (GimpImage *image)
   return style;
 }
 
+/**
+ * _gimp_image_grid_get_style: (skip)
+ * @image_ID: The image.
+ *
+ * Gets the style of an image's grid.
+ *
+ * This procedure retrieves the style of an image's grid.
+ *
+ * Returns: The image's grid style.
+ *
+ * Since: 2.4
+ **/
+GimpGridStyle
+_gimp_image_grid_get_style (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpGridStyle style = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-get-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-get-style",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    style = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return style;
+}
+
 /**
  * gimp_image_grid_set_style:
  * @image: The image.
@@ -496,3 +915,47 @@ gimp_image_grid_set_style (GimpImage     *image,
 
   return success;
 }
+
+/**
+ * _gimp_image_grid_set_style: (skip)
+ * @image_ID: The image.
+ * @style: The image's grid style.
+ *
+ * Sets the style unit of an image's grid.
+ *
+ * This procedure sets the style of an image's grid. It takes the image
+ * and the new style as parameters.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_image_grid_set_style (gint32        image_ID,
+                            GimpGridStyle style)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_GRID_STYLE, style,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-grid-set-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-grid-set-style",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpimagegrid_pdb.h b/libgimp/gimpimagegrid_pdb.h
index e256944329..204e37585c 100644
--- a/libgimp/gimpimagegrid_pdb.h
+++ b/libgimp/gimpimagegrid_pdb.h
@@ -32,29 +32,62 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean      gimp_image_grid_get_spacing          (GimpImage     *image,
-                                                    gdouble       *xspacing,
-                                                    gdouble       *yspacing);
-gboolean      gimp_image_grid_set_spacing          (GimpImage     *image,
-                                                    gdouble        xspacing,
-                                                    gdouble        yspacing);
-gboolean      gimp_image_grid_get_offset           (GimpImage     *image,
-                                                    gdouble       *xoffset,
-                                                    gdouble       *yoffset);
-gboolean      gimp_image_grid_set_offset           (GimpImage     *image,
-                                                    gdouble        xoffset,
-                                                    gdouble        yoffset);
-gboolean      gimp_image_grid_get_foreground_color (GimpImage     *image,
-                                                    GimpRGB       *fgcolor);
-gboolean      gimp_image_grid_set_foreground_color (GimpImage     *image,
-                                                    const GimpRGB *fgcolor);
-gboolean      gimp_image_grid_get_background_color (GimpImage     *image,
-                                                    GimpRGB       *bgcolor);
-gboolean      gimp_image_grid_set_background_color (GimpImage     *image,
-                                                    const GimpRGB *bgcolor);
-GimpGridStyle gimp_image_grid_get_style            (GimpImage     *image);
-gboolean      gimp_image_grid_set_style            (GimpImage     *image,
-                                                    GimpGridStyle  style);
+gboolean                      gimp_image_grid_get_spacing           (GimpImage     *image,
+                                                                     gdouble       *xspacing,
+                                                                     gdouble       *yspacing);
+GIMP_DEPRECATED_FOR(gimp_image_grid_get_spacing)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_get_spacing          (gint32         image_ID,
+                                                                     gdouble       *xspacing,
+                                                                     gdouble       *yspacing);
+gboolean                      gimp_image_grid_set_spacing           (GimpImage     *image,
+                                                                     gdouble        xspacing,
+                                                                     gdouble        yspacing);
+GIMP_DEPRECATED_FOR(gimp_image_grid_set_spacing)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_set_spacing          (gint32         image_ID,
+                                                                     gdouble        xspacing,
+                                                                     gdouble        yspacing);
+gboolean                      gimp_image_grid_get_offset            (GimpImage     *image,
+                                                                     gdouble       *xoffset,
+                                                                     gdouble       *yoffset);
+GIMP_DEPRECATED_FOR(gimp_image_grid_get_offset)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_get_offset           (gint32         image_ID,
+                                                                     gdouble       *xoffset,
+                                                                     gdouble       *yoffset);
+gboolean                      gimp_image_grid_set_offset            (GimpImage     *image,
+                                                                     gdouble        xoffset,
+                                                                     gdouble        yoffset);
+GIMP_DEPRECATED_FOR(gimp_image_grid_set_offset)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_set_offset           (gint32         image_ID,
+                                                                     gdouble        xoffset,
+                                                                     gdouble        yoffset);
+gboolean                      gimp_image_grid_get_foreground_color  (GimpImage     *image,
+                                                                     GimpRGB       *fgcolor);
+GIMP_DEPRECATED_FOR(gimp_image_grid_get_foreground_color)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_get_foreground_color (gint32         image_ID,
+                                                                     GimpRGB       *fgcolor);
+gboolean                      gimp_image_grid_set_foreground_color  (GimpImage     *image,
+                                                                     const GimpRGB *fgcolor);
+GIMP_DEPRECATED_FOR(gimp_image_grid_set_foreground_color)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_set_foreground_color (gint32         image_ID,
+                                                                     const GimpRGB *fgcolor);
+gboolean                      gimp_image_grid_get_background_color  (GimpImage     *image,
+                                                                     GimpRGB       *bgcolor);
+GIMP_DEPRECATED_FOR(gimp_image_grid_get_background_color)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_get_background_color (gint32         image_ID,
+                                                                     GimpRGB       *bgcolor);
+gboolean                      gimp_image_grid_set_background_color  (GimpImage     *image,
+                                                                     const GimpRGB *bgcolor);
+GIMP_DEPRECATED_FOR(gimp_image_grid_set_background_color)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_set_background_color (gint32         image_ID,
+                                                                     const GimpRGB *bgcolor);
+GimpGridStyle                 gimp_image_grid_get_style             (GimpImage     *image);
+GIMP_DEPRECATED_FOR(gimp_image_grid_get_style)
+G_GNUC_INTERNAL GimpGridStyle _gimp_image_grid_get_style            (gint32         image_ID);
+gboolean                      gimp_image_grid_set_style             (GimpImage     *image,
+                                                                     GimpGridStyle  style);
+GIMP_DEPRECATED_FOR(gimp_image_grid_set_style)
+G_GNUC_INTERNAL gboolean      _gimp_image_grid_set_style            (gint32         image_ID,
+                                                                     GimpGridStyle  style);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c
index 43e6342f2b..84d027d58b 100644
--- a/libgimp/gimpimageguides_pdb.c
+++ b/libgimp/gimpimageguides_pdb.c
@@ -78,6 +78,50 @@ gimp_image_add_hguide (GimpImage *image,
   return guide_ID;
 }
 
+/**
+ * _gimp_image_add_hguide: (skip)
+ * @image_ID: The image.
+ * @yposition: The guide's y-offset from top of image.
+ *
+ * Add a horizontal guide to an image.
+ *
+ * This procedure adds a horizontal guide to an image. It takes the
+ * input image and the y-position of the new guide as parameters. It
+ * returns the guide ID of the new guide.
+ *
+ * Returns: The new guide.
+ **/
+gint32
+_gimp_image_add_hguide (gint32 image_ID,
+                        gint   yposition)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 guide_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, yposition,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-add-hguide",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-add-hguide",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return guide_ID;
+}
+
 /**
  * gimp_image_add_vguide:
  * @image: The image.
@@ -122,6 +166,50 @@ gimp_image_add_vguide (GimpImage *image,
   return guide_ID;
 }
 
+/**
+ * _gimp_image_add_vguide: (skip)
+ * @image_ID: The image.
+ * @xposition: The guide's x-offset from left of image.
+ *
+ * Add a vertical guide to an image.
+ *
+ * This procedure adds a vertical guide to an image. It takes the input
+ * image and the x-position of the new guide as parameters. It returns
+ * the guide ID of the new guide.
+ *
+ * Returns: The new guide.
+ **/
+gint32
+_gimp_image_add_vguide (gint32 image_ID,
+                        gint   xposition)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 guide_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, xposition,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-add-vguide",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-add-vguide",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return guide_ID;
+}
+
 /**
  * gimp_image_delete_guide:
  * @image: The image.
@@ -164,6 +252,48 @@ gimp_image_delete_guide (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_delete_guide: (skip)
+ * @image_ID: The image.
+ * @guide_ID: The ID of the guide to be removed.
+ *
+ * Deletes a guide from an image.
+ *
+ * This procedure takes an image and a guide ID as input and removes
+ * the specified guide from the specified image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_delete_guide (gint32 image_ID,
+                          gint32 guide_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, guide_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-delete-guide",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-delete-guide",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_find_next_guide:
  * @image: The image.
@@ -210,6 +340,52 @@ gimp_image_find_next_guide (GimpImage *image,
   return next_guide_ID;
 }
 
+/**
+ * _gimp_image_find_next_guide: (skip)
+ * @image_ID: The image.
+ * @guide_ID: The ID of the current guide (0 if first invocation).
+ *
+ * Find next guide on an image.
+ *
+ * This procedure takes an image and a guide ID as input and finds the
+ * guide ID of the successor of the given guide ID in the image's guide
+ * list. If the supplied guide ID is 0, the procedure will return the
+ * first Guide. The procedure will return 0 if given the final guide ID
+ * as an argument or the image has no guides.
+ *
+ * Returns: The next guide's ID.
+ **/
+gint32
+_gimp_image_find_next_guide (gint32 image_ID,
+                             gint32 guide_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 next_guide_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, guide_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-find-next-guide",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-find-next-guide",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    next_guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return next_guide_ID;
+}
+
 /**
  * gimp_image_get_guide_orientation:
  * @image: The image.
@@ -253,6 +429,49 @@ gimp_image_get_guide_orientation (GimpImage *image,
   return orientation;
 }
 
+/**
+ * _gimp_image_get_guide_orientation: (skip)
+ * @image_ID: The image.
+ * @guide_ID: The guide.
+ *
+ * Get orientation of a guide on an image.
+ *
+ * This procedure takes an image and a guide ID as input and returns
+ * the orientations of the guide.
+ *
+ * Returns: The guide's orientation.
+ **/
+GimpOrientationType
+_gimp_image_get_guide_orientation (gint32 image_ID,
+                                   gint32 guide_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, guide_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-guide-orientation",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-guide-orientation",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    orientation = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return orientation;
+}
+
 /**
  * gimp_image_get_guide_position:
  * @image: The image.
@@ -295,3 +514,46 @@ gimp_image_get_guide_position (GimpImage *image,
 
   return position;
 }
+
+/**
+ * _gimp_image_get_guide_position: (skip)
+ * @image_ID: The image.
+ * @guide_ID: The guide.
+ *
+ * Get position of a guide on an image.
+ *
+ * This procedure takes an image and a guide ID as input and returns
+ * the position of the guide relative to the top or left of the image.
+ *
+ * Returns: The guide's position relative to top or left of image.
+ **/
+gint
+_gimp_image_get_guide_position (gint32 image_ID,
+                                gint32 guide_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, guide_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-guide-position",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-guide-position",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    position = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return position;
+}
diff --git a/libgimp/gimpimageguides_pdb.h b/libgimp/gimpimageguides_pdb.h
index 6e69c4fdec..c510c8c046 100644
--- a/libgimp/gimpimageguides_pdb.h
+++ b/libgimp/gimpimageguides_pdb.h
@@ -32,18 +32,36 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32              gimp_image_add_hguide            (GimpImage *image,
-                                                      gint       yposition);
-gint32              gimp_image_add_vguide            (GimpImage *image,
-                                                      gint       xposition);
-gboolean            gimp_image_delete_guide          (GimpImage *image,
-                                                      gint32     guide_ID);
-gint32              gimp_image_find_next_guide       (GimpImage *image,
-                                                      gint32     guide_ID);
-GimpOrientationType gimp_image_get_guide_orientation (GimpImage *image,
-                                                      gint32     guide_ID);
-gint                gimp_image_get_guide_position    (GimpImage *image,
-                                                      gint32     guide_ID);
+gint32                              gimp_image_add_hguide             (GimpImage *image,
+                                                                       gint       yposition);
+GIMP_DEPRECATED_FOR(gimp_image_add_hguide)
+G_GNUC_INTERNAL gint32              _gimp_image_add_hguide            (gint32     image_ID,
+                                                                       gint       yposition);
+gint32                              gimp_image_add_vguide             (GimpImage *image,
+                                                                       gint       xposition);
+GIMP_DEPRECATED_FOR(gimp_image_add_vguide)
+G_GNUC_INTERNAL gint32              _gimp_image_add_vguide            (gint32     image_ID,
+                                                                       gint       xposition);
+gboolean                            gimp_image_delete_guide           (GimpImage *image,
+                                                                       gint32     guide_ID);
+GIMP_DEPRECATED_FOR(gimp_image_delete_guide)
+G_GNUC_INTERNAL gboolean            _gimp_image_delete_guide          (gint32     image_ID,
+                                                                       gint32     guide_ID);
+gint32                              gimp_image_find_next_guide        (GimpImage *image,
+                                                                       gint32     guide_ID);
+GIMP_DEPRECATED_FOR(gimp_image_find_next_guide)
+G_GNUC_INTERNAL gint32              _gimp_image_find_next_guide       (gint32     image_ID,
+                                                                       gint32     guide_ID);
+GimpOrientationType                 gimp_image_get_guide_orientation  (GimpImage *image,
+                                                                       gint32     guide_ID);
+GIMP_DEPRECATED_FOR(gimp_image_get_guide_orientation)
+G_GNUC_INTERNAL GimpOrientationType _gimp_image_get_guide_orientation (gint32     image_ID,
+                                                                       gint32     guide_ID);
+gint                                gimp_image_get_guide_position     (GimpImage *image,
+                                                                       gint32     guide_ID);
+GIMP_DEPRECATED_FOR(gimp_image_get_guide_position)
+G_GNUC_INTERNAL gint                _gimp_image_get_guide_position    (gint32     image_ID,
+                                                                       gint32     guide_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c
index 4343f0ac74..effb078a37 100644
--- a/libgimp/gimpimagesamplepoints_pdb.c
+++ b/libgimp/gimpimagesamplepoints_pdb.c
@@ -83,6 +83,55 @@ gimp_image_add_sample_point (GimpImage *image,
   return sample_point_ID;
 }
 
+/**
+ * _gimp_image_add_sample_point: (skip)
+ * @image_ID: The image.
+ * @position_x: The guide'sample points x-offset from left of image.
+ * @position_y: The guide'sample points y-offset from top of image.
+ *
+ * Add a sample point to an image.
+ *
+ * This procedure adds a sample point to an image. It takes the input
+ * image and the position of the new sample points as parameters. It
+ * returns the sample point ID of the new sample point.
+ *
+ * Returns: The new sample point.
+ *
+ * Since: 2.10
+ **/
+gint32
+_gimp_image_add_sample_point (gint32 image_ID,
+                              gint   position_x,
+                              gint   position_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 sample_point_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, position_x,
+                                          G_TYPE_INT, position_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-add-sample-point",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-add-sample-point",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return sample_point_ID;
+}
+
 /**
  * gimp_image_delete_sample_point:
  * @image: The image.
@@ -127,6 +176,50 @@ gimp_image_delete_sample_point (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_delete_sample_point: (skip)
+ * @image_ID: The image.
+ * @sample_point_ID: The ID of the sample point to be removed.
+ *
+ * Deletes a sample point from an image.
+ *
+ * This procedure takes an image and a sample point ID as input and
+ * removes the specified sample point from the specified image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_image_delete_sample_point (gint32 image_ID,
+                                 gint32 sample_point_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, sample_point_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-delete-sample-point",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-delete-sample-point",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_find_next_sample_point:
  * @image: The image.
@@ -176,6 +269,55 @@ gimp_image_find_next_sample_point (GimpImage *image,
   return next_sample_point_ID;
 }
 
+/**
+ * _gimp_image_find_next_sample_point: (skip)
+ * @image_ID: The image.
+ * @sample_point_ID: The ID of the current sample point (0 if first invocation).
+ *
+ * Find next sample point on an image.
+ *
+ * This procedure takes an image and a sample point ID as input and
+ * finds the sample point ID of the successor of the given sample point
+ * ID in the image's sample point list. If the supplied sample point ID
+ * is 0, the procedure will return the first sample point. The
+ * procedure will return 0 if given the final sample point ID as an
+ * argument or the image has no sample points.
+ *
+ * Returns: The next sample point's ID.
+ *
+ * Since: 2.10
+ **/
+gint32
+_gimp_image_find_next_sample_point (gint32 image_ID,
+                                    gint32 sample_point_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 next_sample_point_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, sample_point_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-find-next-sample-point",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-find-next-sample-point",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    next_sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return next_sample_point_ID;
+}
+
 /**
  * gimp_image_get_sample_point_position:
  * @image: The image.
@@ -226,3 +368,54 @@ gimp_image_get_sample_point_position (GimpImage *image,
 
   return position_x;
 }
+
+/**
+ * _gimp_image_get_sample_point_position: (skip)
+ * @image_ID: The image.
+ * @sample_point_ID: The guide.
+ * @position_y: (out): The sample points's position relative to top of image.
+ *
+ * Get position of a sample point on an image.
+ *
+ * This procedure takes an image and a sample point ID as input and
+ * returns the position of the sample point relative to the top and
+ * left of the image.
+ *
+ * Returns: The sample points's position relative to top of image.
+ *
+ * Since: 2.10
+ **/
+gint
+_gimp_image_get_sample_point_position (gint32  image_ID,
+                                       gint32  sample_point_ID,
+                                       gint   *position_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint position_x = G_MININT;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_UINT, sample_point_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-get-sample-point-position",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-get-sample-point-position",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      position_x = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *position_y = g_value_get_int (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return position_x;
+}
diff --git a/libgimp/gimpimagesamplepoints_pdb.h b/libgimp/gimpimagesamplepoints_pdb.h
index feb7b20bd9..f0d56994f9 100644
--- a/libgimp/gimpimagesamplepoints_pdb.h
+++ b/libgimp/gimpimagesamplepoints_pdb.h
@@ -32,16 +32,30 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32   gimp_image_add_sample_point          (GimpImage *image,
-                                               gint       position_x,
-                                               gint       position_y);
-gboolean gimp_image_delete_sample_point       (GimpImage *image,
-                                               gint32     sample_point_ID);
-gint32   gimp_image_find_next_sample_point    (GimpImage *image,
-                                               gint32     sample_point_ID);
-gint     gimp_image_get_sample_point_position (GimpImage *image,
-                                               gint32     sample_point_ID,
-                                               gint      *position_y);
+gint32                   gimp_image_add_sample_point           (GimpImage *image,
+                                                                gint       position_x,
+                                                                gint       position_y);
+GIMP_DEPRECATED_FOR(gimp_image_add_sample_point)
+G_GNUC_INTERNAL gint32   _gimp_image_add_sample_point          (gint32     image_ID,
+                                                                gint       position_x,
+                                                                gint       position_y);
+gboolean                 gimp_image_delete_sample_point        (GimpImage *image,
+                                                                gint32     sample_point_ID);
+GIMP_DEPRECATED_FOR(gimp_image_delete_sample_point)
+G_GNUC_INTERNAL gboolean _gimp_image_delete_sample_point       (gint32     image_ID,
+                                                                gint32     sample_point_ID);
+gint32                   gimp_image_find_next_sample_point     (GimpImage *image,
+                                                                gint32     sample_point_ID);
+GIMP_DEPRECATED_FOR(gimp_image_find_next_sample_point)
+G_GNUC_INTERNAL gint32   _gimp_image_find_next_sample_point    (gint32     image_ID,
+                                                                gint32     sample_point_ID);
+gint                     gimp_image_get_sample_point_position  (GimpImage *image,
+                                                                gint32     sample_point_ID,
+                                                                gint      *position_y);
+GIMP_DEPRECATED_FOR(gimp_image_get_sample_point_position)
+G_GNUC_INTERNAL gint     _gimp_image_get_sample_point_position (gint32     image_ID,
+                                                                gint32     sample_point_ID,
+                                                                gint      *position_y);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index 6b025373d5..c4e5ef3dea 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -99,6 +99,71 @@ gimp_image_select_color (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_color: (skip)
+ * @image_ID: The affected image.
+ * @operation: The selection operation.
+ * @drawable_ID: The affected drawable.
+ * @color: The color to select.
+ *
+ * Create a selection by selecting all pixels (in the specified
+ * drawable) with the same (or similar) color to that specified.
+ *
+ * This tool creates a selection over the specified image. A by-color
+ * selection is determined by the supplied color under the constraints
+ * of the current context settings. Essentially, all pixels (in the
+ * drawable) that have color sufficiently close to the specified color
+ * (as determined by the threshold and criterion context values) are
+ * included in the selection. To select transparent regions, the color
+ * specified must also have minimum alpha.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius(), gimp_context_set_sample_merged(),
+ * gimp_context_set_sample_criterion(),
+ * gimp_context_set_sample_threshold(),
+ * gimp_context_set_sample_transparent().
+ *
+ * In the case of a merged sampling, the supplied drawable is ignored.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_color (gint32          image_ID,
+                          GimpChannelOps  operation,
+                          gint32          drawable_ID,
+                          const GimpRGB  *color)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_RGB, color,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_contiguous_color:
  * @image: The affected image.
@@ -176,6 +241,83 @@ gimp_image_select_contiguous_color (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_contiguous_color: (skip)
+ * @image_ID: The affected image.
+ * @operation: The selection operation.
+ * @drawable_ID: The affected drawable.
+ * @x: x coordinate of initial seed fill point: (image coordinates).
+ * @y: y coordinate of initial seed fill point: (image coordinates).
+ *
+ * Create a selection by selecting all pixels around specified
+ * coordinates with the same (or similar) color to that at the
+ * coordinates.
+ *
+ * This tool creates a contiguous selection over the specified image. A
+ * contiguous color selection is determined by a seed fill under the
+ * constraints of the current context settings. Essentially, the color
+ * at the specified coordinates (in the drawable) is measured and the
+ * selection expands outwards from that point to any adjacent pixels
+ * which are not significantly different (as determined by the
+ * threshold and criterion context settings). This process continues
+ * until no more expansion is possible. If antialiasing is turned on,
+ * the final selection mask will contain intermediate values based on
+ * close misses to the threshold bar at pixels along the seed fill
+ * boundary.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius(), gimp_context_set_sample_merged(),
+ * gimp_context_set_sample_criterion(),
+ * gimp_context_set_sample_threshold(),
+ * gimp_context_set_sample_transparent(),
+ * gimp_context_set_diagonal_neighbors().
+ *
+ * In the case of a merged sampling, the supplied drawable is ignored.
+ * If the sample is merged, the specified coordinates are relative to
+ * the image origin; otherwise, they are relative to the drawable's
+ * origin.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_contiguous_color (gint32         image_ID,
+                                     GimpChannelOps operation,
+                                     gint32         drawable_ID,
+                                     gdouble        x,
+                                     gdouble        y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-contiguous-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-contiguous-color",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_rectangle:
  * @image: The image.
@@ -236,6 +378,66 @@ gimp_image_select_rectangle (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_rectangle: (skip)
+ * @image_ID: The image.
+ * @operation: The selection operation.
+ * @x: x coordinate of upper-left corner of rectangle.
+ * @y: y coordinate of upper-left corner of rectangle.
+ * @width: The width of the rectangle.
+ * @height: The height of the rectangle.
+ *
+ * Create a rectangular selection over the specified image;
+ *
+ * This tool creates a rectangular selection over the specified image.
+ * The rectangular region can be either added to, subtracted from, or
+ * replace the contents of the previous selection mask.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_feather(), gimp_context_set_feather_radius().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_rectangle (gint32         image_ID,
+                              GimpChannelOps operation,
+                              gdouble        x,
+                              gdouble        y,
+                              gdouble        width,
+                              gdouble        height)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-rectangle",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-rectangle",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_round_rectangle:
  * @image: The image.
@@ -305,6 +507,75 @@ gimp_image_select_round_rectangle (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_round_rectangle: (skip)
+ * @image_ID: The image.
+ * @operation: The selection operation.
+ * @x: x coordinate of upper-left corner of rectangle.
+ * @y: y coordinate of upper-left corner of rectangle.
+ * @width: The width of the rectangle.
+ * @height: The height of the rectangle.
+ * @corner_radius_x: The corner radius in X direction.
+ * @corner_radius_y: The corner radius in Y direction.
+ *
+ * Create a rectangular selection with round corners over the specified
+ * image;
+ *
+ * This tool creates a rectangular selection with round corners over
+ * the specified image. The rectangular region can be either added to,
+ * subtracted from, or replace the contents of the previous selection
+ * mask.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_round_rectangle (gint32         image_ID,
+                                    GimpChannelOps operation,
+                                    gdouble        x,
+                                    gdouble        y,
+                                    gdouble        width,
+                                    gdouble        height,
+                                    gdouble        corner_radius_x,
+                                    gdouble        corner_radius_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
+                                          G_TYPE_DOUBLE, corner_radius_x,
+                                          G_TYPE_DOUBLE, corner_radius_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-round-rectangle",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-round-rectangle",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_ellipse:
  * @image: The image.
@@ -366,6 +637,67 @@ gimp_image_select_ellipse (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_ellipse: (skip)
+ * @image_ID: The image.
+ * @operation: The selection operation.
+ * @x: x coordinate of upper-left corner of ellipse bounding box.
+ * @y: y coordinate of upper-left corner of ellipse bounding box.
+ * @width: The width of the ellipse.
+ * @height: The height of the ellipse.
+ *
+ * Create an elliptical selection over the specified image.
+ *
+ * This tool creates an elliptical selection over the specified image.
+ * The elliptical region can be either added to, subtracted from, or
+ * replace the contents of the previous selection mask.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_ellipse (gint32         image_ID,
+                            GimpChannelOps operation,
+                            gdouble        x,
+                            gdouble        y,
+                            gdouble        width,
+                            gdouble        height)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-ellipse",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-ellipse",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_polygon:
  * @image: The image.
@@ -427,6 +759,67 @@ gimp_image_select_polygon (GimpImage      *image,
   return success;
 }
 
+/**
+ * _gimp_image_select_polygon: (skip)
+ * @image_ID: The image.
+ * @operation: The selection operation.
+ * @num_segs: Number of points (count 1 coordinate as two points).
+ * @segs: (array length=num_segs) (element-type gdouble): Array of points: { p1.x, p1.y, p2.x, p2.y, ..., 
pn.x, pn.y}.
+ *
+ * Create a polygonal selection over the specified image.
+ *
+ * This tool creates a polygonal selection over the specified image.
+ * The polygonal region can be either added to, subtracted from, or
+ * replace the contents of the previous selection mask. The polygon is
+ * specified through an array of floating point numbers and its length.
+ * The length of array must be 2n, where n is the number of points.
+ * Each point is defined by 2 floating point values which correspond to
+ * the x and y coordinates. If the final point does not connect to the
+ * starting point, a connecting segment is automatically added.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_polygon (gint32          image_ID,
+                            GimpChannelOps  operation,
+                            gint            num_segs,
+                            const gdouble  *segs)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_INT, num_segs,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-polygon",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-polygon",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_select_item:
  * @image: The image.
@@ -479,3 +872,56 @@ gimp_image_select_item (GimpImage      *image,
 
   return success;
 }
+
+/**
+ * _gimp_image_select_item: (skip)
+ * @image_ID: The image.
+ * @operation: The desired operation with current selection.
+ * @item_ID: The item to render to the selection.
+ *
+ * Transforms the specified item into a selection
+ *
+ * This procedure renders the item's outline into the current selection
+ * of the image the item belongs to. What exactly the item's outline is
+ * depends on the item type: for layers, it's the layer's alpha
+ * channel, for vectors the vector's shape.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_antialias(), gimp_context_set_feather(),
+ * gimp_context_set_feather_radius().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_image_select_item (gint32         image_ID,
+                         GimpChannelOps operation,
+                         gint32         item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-select-item",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-select-item",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpimageselect_pdb.h b/libgimp/gimpimageselect_pdb.h
index 9918092421..01ae0f879b 100644
--- a/libgimp/gimpimageselect_pdb.h
+++ b/libgimp/gimpimageselect_pdb.h
@@ -32,42 +32,85 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_image_select_color            (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gint32          drawable_ID,
-                                             const GimpRGB  *color);
-gboolean gimp_image_select_contiguous_color (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gint32          drawable_ID,
-                                             gdouble         x,
-                                             gdouble         y);
-gboolean gimp_image_select_rectangle        (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gdouble         x,
-                                             gdouble         y,
-                                             gdouble         width,
-                                             gdouble         height);
-gboolean gimp_image_select_round_rectangle  (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gdouble         x,
-                                             gdouble         y,
-                                             gdouble         width,
-                                             gdouble         height,
-                                             gdouble         corner_radius_x,
-                                             gdouble         corner_radius_y);
-gboolean gimp_image_select_ellipse          (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gdouble         x,
-                                             gdouble         y,
-                                             gdouble         width,
-                                             gdouble         height);
-gboolean gimp_image_select_polygon          (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gint            num_segs,
-                                             const gdouble  *segs);
-gboolean gimp_image_select_item             (GimpImage      *image,
-                                             GimpChannelOps  operation,
-                                             gint32          item_ID);
+gboolean                 gimp_image_select_color             (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gint32          drawable_ID,
+                                                              const GimpRGB  *color);
+GIMP_DEPRECATED_FOR(gimp_image_select_color)
+G_GNUC_INTERNAL gboolean _gimp_image_select_color            (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gint32          drawable_ID,
+                                                              const GimpRGB  *color);
+gboolean                 gimp_image_select_contiguous_color  (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gint32          drawable_ID,
+                                                              gdouble         x,
+                                                              gdouble         y);
+GIMP_DEPRECATED_FOR(gimp_image_select_contiguous_color)
+G_GNUC_INTERNAL gboolean _gimp_image_select_contiguous_color (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gint32          drawable_ID,
+                                                              gdouble         x,
+                                                              gdouble         y);
+gboolean                 gimp_image_select_rectangle         (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height);
+GIMP_DEPRECATED_FOR(gimp_image_select_rectangle)
+G_GNUC_INTERNAL gboolean _gimp_image_select_rectangle        (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height);
+gboolean                 gimp_image_select_round_rectangle   (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height,
+                                                              gdouble         corner_radius_x,
+                                                              gdouble         corner_radius_y);
+GIMP_DEPRECATED_FOR(gimp_image_select_round_rectangle)
+G_GNUC_INTERNAL gboolean _gimp_image_select_round_rectangle  (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height,
+                                                              gdouble         corner_radius_x,
+                                                              gdouble         corner_radius_y);
+gboolean                 gimp_image_select_ellipse           (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height);
+GIMP_DEPRECATED_FOR(gimp_image_select_ellipse)
+G_GNUC_INTERNAL gboolean _gimp_image_select_ellipse          (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gdouble         x,
+                                                              gdouble         y,
+                                                              gdouble         width,
+                                                              gdouble         height);
+gboolean                 gimp_image_select_polygon           (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gint            num_segs,
+                                                              const gdouble  *segs);
+GIMP_DEPRECATED_FOR(gimp_image_select_polygon)
+G_GNUC_INTERNAL gboolean _gimp_image_select_polygon          (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gint            num_segs,
+                                                              const gdouble  *segs);
+gboolean                 gimp_image_select_item              (GimpImage      *image,
+                                                              GimpChannelOps  operation,
+                                                              gint32          item_ID);
+GIMP_DEPRECATED_FOR(gimp_image_select_item)
+G_GNUC_INTERNAL gboolean _gimp_image_select_item             (gint32          image_ID,
+                                                              GimpChannelOps  operation,
+                                                              gint32          item_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c
index e159b40141..daff6083c3 100644
--- a/libgimp/gimpimagetransform_pdb.c
+++ b/libgimp/gimpimagetransform_pdb.c
@@ -90,6 +90,62 @@ gimp_image_resize (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_resize: (skip)
+ * @image_ID: The image.
+ * @new_width: New image width.
+ * @new_height: New image height.
+ * @offx: x offset between upper left corner of old and new images: (new - old).
+ * @offy: y offset between upper left corner of old and new images: (new - old).
+ *
+ * Resize the image to the specified extents.
+ *
+ * This procedure resizes the image so that it's new width and height
+ * are equal to the supplied parameters. Offsets are also provided
+ * which describe the position of the previous image's content. All
+ * channels within the image are resized according to the specified
+ * parameters; this includes the image selection mask. All layers
+ * within the image are repositioned according to the specified
+ * offsets.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_resize (gint32 image_ID,
+                    gint   new_width,
+                    gint   new_height,
+                    gint   offx,
+                    gint   offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, new_width,
+                                          G_TYPE_INT, new_height,
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-resize",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-resize",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_resize_to_layers:
  * @image: The image.
@@ -133,6 +189,49 @@ gimp_image_resize_to_layers (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_resize_to_layers: (skip)
+ * @image_ID: The image.
+ *
+ * Resize the image to fit all layers.
+ *
+ * This procedure resizes the image to the bounding box of all layers
+ * of the image. All channels within the image are resized to the new
+ * size; this includes the image selection mask. All layers within the
+ * image are repositioned to the new image area.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.2
+ **/
+gboolean
+_gimp_image_resize_to_layers (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-resize-to-layers",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-resize-to-layers",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_scale:
  * @image: The image.
@@ -181,6 +280,54 @@ gimp_image_scale (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_scale: (skip)
+ * @image_ID: The image.
+ * @new_width: New image width.
+ * @new_height: New image height.
+ *
+ * Scale the image using the default interpolation method.
+ *
+ * This procedure scales the image so that its new width and height are
+ * equal to the supplied parameters. All layers and channels within the
+ * image are scaled according to the specified parameters; this
+ * includes the image selection mask. The interpolation method used can
+ * be set with gimp_context_set_interpolation().
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_scale (gint32 image_ID,
+                   gint   new_width,
+                   gint   new_height)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, new_width,
+                                          G_TYPE_INT, new_height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-scale",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-scale",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_crop:
  * @image: The image.
@@ -236,6 +383,61 @@ gimp_image_crop (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_image_crop: (skip)
+ * @image_ID: The image.
+ * @new_width: New image width: (0 < new_width <= width).
+ * @new_height: New image height: (0 < new_height <= height).
+ * @offx: X offset: (0 <= offx <= (width - new_width)).
+ * @offy: Y offset: (0 <= offy <= (height - new_height)).
+ *
+ * Crop the image to the specified extents.
+ *
+ * This procedure crops the image so that it's new width and height are
+ * equal to the supplied parameters. Offsets are also provided which
+ * describe the position of the previous image's content. All channels
+ * and layers within the image are cropped to the new image extents;
+ * this includes the image selection mask. If any parameters are out of
+ * range, an error is returned.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_crop (gint32 image_ID,
+                  gint   new_width,
+                  gint   new_height,
+                  gint   offx,
+                  gint   offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, new_width,
+                                          G_TYPE_INT, new_height,
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-crop",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-crop",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_flip:
  * @image: The image.
@@ -277,6 +479,47 @@ gimp_image_flip (GimpImage           *image,
   return success;
 }
 
+/**
+ * _gimp_image_flip: (skip)
+ * @image_ID: The image.
+ * @flip_type: Type of flip.
+ *
+ * Flips the image horizontally or vertically.
+ *
+ * This procedure flips (mirrors) the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_flip (gint32              image_ID,
+                  GimpOrientationType flip_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ORIENTATION_TYPE, flip_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-flip",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-flip",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_rotate:
  * @image: The image.
@@ -317,3 +560,44 @@ gimp_image_rotate (GimpImage        *image,
 
   return success;
 }
+
+/**
+ * _gimp_image_rotate: (skip)
+ * @image_ID: The image.
+ * @rotate_type: Angle of rotation.
+ *
+ * Rotates the image by the specified degrees.
+ *
+ * This procedure rotates the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_rotate (gint32           image_ID,
+                    GimpRotationType rotate_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ROTATION_TYPE, rotate_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-rotate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-rotate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
diff --git a/libgimp/gimpimagetransform_pdb.h b/libgimp/gimpimagetransform_pdb.h
index f82c018682..bee76b6852 100644
--- a/libgimp/gimpimagetransform_pdb.h
+++ b/libgimp/gimpimagetransform_pdb.h
@@ -32,24 +32,48 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_image_resize           (GimpImage           *image,
-                                      gint                 new_width,
-                                      gint                 new_height,
-                                      gint                 offx,
-                                      gint                 offy);
-gboolean gimp_image_resize_to_layers (GimpImage           *image);
-gboolean gimp_image_scale            (GimpImage           *image,
-                                      gint                 new_width,
-                                      gint                 new_height);
-gboolean gimp_image_crop             (GimpImage           *image,
-                                      gint                 new_width,
-                                      gint                 new_height,
-                                      gint                 offx,
-                                      gint                 offy);
-gboolean gimp_image_flip             (GimpImage           *image,
-                                      GimpOrientationType  flip_type);
-gboolean gimp_image_rotate           (GimpImage           *image,
-                                      GimpRotationType     rotate_type);
+gboolean                 gimp_image_resize            (GimpImage           *image,
+                                                       gint                 new_width,
+                                                       gint                 new_height,
+                                                       gint                 offx,
+                                                       gint                 offy);
+GIMP_DEPRECATED_FOR(gimp_image_resize)
+G_GNUC_INTERNAL gboolean _gimp_image_resize           (gint32               image_ID,
+                                                       gint                 new_width,
+                                                       gint                 new_height,
+                                                       gint                 offx,
+                                                       gint                 offy);
+gboolean                 gimp_image_resize_to_layers  (GimpImage           *image);
+GIMP_DEPRECATED_FOR(gimp_image_resize_to_layers)
+G_GNUC_INTERNAL gboolean _gimp_image_resize_to_layers (gint32               image_ID);
+gboolean                 gimp_image_scale             (GimpImage           *image,
+                                                       gint                 new_width,
+                                                       gint                 new_height);
+GIMP_DEPRECATED_FOR(gimp_image_scale)
+G_GNUC_INTERNAL gboolean _gimp_image_scale            (gint32               image_ID,
+                                                       gint                 new_width,
+                                                       gint                 new_height);
+gboolean                 gimp_image_crop              (GimpImage           *image,
+                                                       gint                 new_width,
+                                                       gint                 new_height,
+                                                       gint                 offx,
+                                                       gint                 offy);
+GIMP_DEPRECATED_FOR(gimp_image_crop)
+G_GNUC_INTERNAL gboolean _gimp_image_crop             (gint32               image_ID,
+                                                       gint                 new_width,
+                                                       gint                 new_height,
+                                                       gint                 offx,
+                                                       gint                 offy);
+gboolean                 gimp_image_flip              (GimpImage           *image,
+                                                       GimpOrientationType  flip_type);
+GIMP_DEPRECATED_FOR(gimp_image_flip)
+G_GNUC_INTERNAL gboolean _gimp_image_flip             (gint32               image_ID,
+                                                       GimpOrientationType  flip_type);
+gboolean                 gimp_image_rotate            (GimpImage           *image,
+                                                       GimpRotationType     rotate_type);
+GIMP_DEPRECATED_FOR(gimp_image_rotate)
+G_GNUC_INTERNAL gboolean _gimp_image_rotate           (gint32               image_ID,
+                                                       GimpRotationType     rotate_type);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c
index 0cf0465c62..6fec1695a5 100644
--- a/libgimp/gimpimageundo_pdb.c
+++ b/libgimp/gimpimageundo_pdb.c
@@ -75,6 +75,47 @@ gimp_image_undo_group_start (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_undo_group_start: (skip)
+ * @image_ID: The ID of the image in which to open an undo group.
+ *
+ * Starts a group undo.
+ *
+ * This function is used to start a group undo--necessary for logically
+ * combining two or more undo operations into a single operation. This
+ * call must be used in conjunction with a gimp_image_undo_group_end()
+ * call.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_undo_group_start (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-group-start",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-group-start",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_undo_group_end:
  * @image: The ID of the image in which to close an undo group.
@@ -114,6 +155,45 @@ gimp_image_undo_group_end (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_image_undo_group_end: (skip)
+ * @image_ID: The ID of the image in which to close an undo group.
+ *
+ * Finish a group undo.
+ *
+ * This function must be called once for each
+ * gimp_image_undo_group_start() call that is made.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_image_undo_group_end (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-group-end",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-group-end",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_image_undo_is_enabled:
  * @image: The image.
@@ -156,6 +236,48 @@ gimp_image_undo_is_enabled (GimpImage *image)
   return enabled;
 }
 
+/**
+ * _gimp_image_undo_is_enabled: (skip)
+ * @image_ID: The image.
+ *
+ * Check if the image's undo stack is enabled.
+ *
+ * This procedure checks if the image's undo stack is currently enabled
+ * or disabled. This is useful when several plug-ins or scripts call
+ * each other and want to check if their caller has already used
+ * gimp_image_undo_disable() or gimp_image_undo_freeze().
+ *
+ * Returns: TRUE if undo is enabled for this image.
+ **/
+gboolean
+_gimp_image_undo_is_enabled (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean enabled = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-is-enabled",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-is-enabled",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return enabled;
+}
+
 /**
  * gimp_image_undo_disable:
  * @image: The image.
@@ -199,6 +321,49 @@ gimp_image_undo_disable (GimpImage *image)
   return disabled;
 }
 
+/**
+ * _gimp_image_undo_disable: (skip)
+ * @image_ID: The image.
+ *
+ * Disable the image's undo stack.
+ *
+ * This procedure disables the image's undo stack, allowing subsequent
+ * operations to ignore their undo steps. This is generally called in
+ * conjunction with gimp_image_undo_enable() to temporarily disable an
+ * image undo stack. This is advantageous because saving undo steps can
+ * be time and memory intensive.
+ *
+ * Returns: TRUE if the image undo has been disabled.
+ **/
+gboolean
+_gimp_image_undo_disable (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean disabled = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-disable",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-disable",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    disabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return disabled;
+}
+
 /**
  * gimp_image_undo_enable:
  * @image: The image.
@@ -241,6 +406,48 @@ gimp_image_undo_enable (GimpImage *image)
   return enabled;
 }
 
+/**
+ * _gimp_image_undo_enable: (skip)
+ * @image_ID: The image.
+ *
+ * Enable the image's undo stack.
+ *
+ * This procedure enables the image's undo stack, allowing subsequent
+ * operations to store their undo steps. This is generally called in
+ * conjunction with gimp_image_undo_disable() to temporarily disable an
+ * image undo stack.
+ *
+ * Returns: TRUE if the image undo has been enabled.
+ **/
+gboolean
+_gimp_image_undo_enable (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean enabled = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-enable",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-enable",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return enabled;
+}
+
 /**
  * gimp_image_undo_freeze:
  * @image: The image.
@@ -290,6 +497,55 @@ gimp_image_undo_freeze (GimpImage *image)
   return frozen;
 }
 
+/**
+ * _gimp_image_undo_freeze: (skip)
+ * @image_ID: The image.
+ *
+ * Freeze the image's undo stack.
+ *
+ * This procedure freezes the image's undo stack, allowing subsequent
+ * operations to ignore their undo steps. This is generally called in
+ * conjunction with gimp_image_undo_thaw() to temporarily disable an
+ * image undo stack. This is advantageous because saving undo steps can
+ * be time and memory intensive. gimp_image_undo_freeze() /
+ * gimp_image_undo_thaw() and gimp_image_undo_disable() /
+ * gimp_image_undo_enable() differ in that the former does not free up
+ * all undo steps when undo is thawed, so is more suited to interactive
+ * in-situ previews. It is important in this case that the image is
+ * back to the same state it was frozen in before thawing, else 'undo'
+ * behaviour is undefined.
+ *
+ * Returns: TRUE if the image undo has been frozen.
+ **/
+gboolean
+_gimp_image_undo_freeze (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean frozen = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-freeze",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-freeze",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    frozen = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return frozen;
+}
+
 /**
  * gimp_image_undo_thaw:
  * @image: The image.
@@ -337,3 +593,51 @@ gimp_image_undo_thaw (GimpImage *image)
 
   return thawed;
 }
+
+/**
+ * _gimp_image_undo_thaw: (skip)
+ * @image_ID: The image.
+ *
+ * Thaw the image's undo stack.
+ *
+ * This procedure thaws the image's undo stack, allowing subsequent
+ * operations to store their undo steps. This is generally called in
+ * conjunction with gimp_image_undo_freeze() to temporarily freeze an
+ * image undo stack. gimp_image_undo_thaw() does NOT free the undo
+ * stack as gimp_image_undo_enable() does, so is suited for situations
+ * where one wishes to leave the undo stack in the same state in which
+ * one found it despite non-destructively playing with the image in the
+ * meantime. An example would be in-situ plug-in previews. Balancing
+ * freezes and thaws and ensuring image consistency is the
+ * responsibility of the caller.
+ *
+ * Returns: TRUE if the image undo has been thawed.
+ **/
+gboolean
+_gimp_image_undo_thaw (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean thawed = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-image-undo-thaw",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-image-undo-thaw",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    thawed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return thawed;
+}
diff --git a/libgimp/gimpimageundo_pdb.h b/libgimp/gimpimageundo_pdb.h
index 3caa0f2227..947e11604a 100644
--- a/libgimp/gimpimageundo_pdb.h
+++ b/libgimp/gimpimageundo_pdb.h
@@ -32,13 +32,27 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_image_undo_group_start (GimpImage *image);
-gboolean gimp_image_undo_group_end   (GimpImage *image);
-gboolean gimp_image_undo_is_enabled  (GimpImage *image);
-gboolean gimp_image_undo_disable     (GimpImage *image);
-gboolean gimp_image_undo_enable      (GimpImage *image);
-gboolean gimp_image_undo_freeze      (GimpImage *image);
-gboolean gimp_image_undo_thaw        (GimpImage *image);
+gboolean                 gimp_image_undo_group_start  (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_group_start)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_group_start (gint32     image_ID);
+gboolean                 gimp_image_undo_group_end    (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_group_end)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_group_end   (gint32     image_ID);
+gboolean                 gimp_image_undo_is_enabled   (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_is_enabled)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_is_enabled  (gint32     image_ID);
+gboolean                 gimp_image_undo_disable      (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_disable)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_disable     (gint32     image_ID);
+gboolean                 gimp_image_undo_enable       (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_enable)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_enable      (gint32     image_ID);
+gboolean                 gimp_image_undo_freeze       (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_freeze)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_freeze      (gint32     image_ID);
+gboolean                 gimp_image_undo_thaw         (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_image_undo_thaw)
+G_GNUC_INTERNAL gboolean _gimp_image_undo_thaw        (gint32     image_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index 5fbbedcaff..1761d1b0b6 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -110,13 +110,54 @@ gimp_item_get_image (gint32 item_ID)
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1)));
+    image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
   return image;
 }
 
+/**
+ * _gimp_item_get_image: (skip)
+ * @item_ID: The item.
+ *
+ * Returns the item's image.
+ *
+ * This procedure returns the item's image.
+ *
+ * Returns: The item's image.
+ *
+ * Since: 2.8
+ **/
+gint32
+_gimp_item_get_image (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 image_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-image",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-image",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return image_ID;
+}
+
 /**
  * gimp_item_delete:
  * @item_ID: The item to delete.
diff --git a/libgimp/gimpitem_pdb.h b/libgimp/gimpitem_pdb.h
index 97c8ede32e..43f961e39f 100644
--- a/libgimp/gimpitem_pdb.h
+++ b/libgimp/gimpitem_pdb.h
@@ -32,52 +32,54 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean      gimp_item_is_valid          (gint32              item_ID);
-GimpImage*    gimp_item_get_image         (gint32              item_ID);
-gboolean      gimp_item_delete            (gint32              item_ID);
-gboolean      gimp_item_is_drawable       (gint32              item_ID);
-gboolean      gimp_item_is_layer          (gint32              item_ID);
-gboolean      gimp_item_is_text_layer     (gint32              item_ID);
-gboolean      gimp_item_is_channel        (gint32              item_ID);
-gboolean      gimp_item_is_layer_mask     (gint32              item_ID);
-gboolean      gimp_item_is_selection      (gint32              item_ID);
-gboolean      gimp_item_is_vectors        (gint32              item_ID);
-gboolean      gimp_item_is_group          (gint32              item_ID);
-gint32        gimp_item_get_parent        (gint32              item_ID);
-gint*         gimp_item_get_children      (gint32              item_ID,
-                                           gint               *num_children);
-gboolean      gimp_item_get_expanded      (gint32              item_ID);
-gboolean      gimp_item_set_expanded      (gint32              item_ID,
-                                           gboolean            expanded);
-gchar*        gimp_item_get_name          (gint32              item_ID);
-gboolean      gimp_item_set_name          (gint32              item_ID,
-                                           const gchar        *name);
-gboolean      gimp_item_get_visible       (gint32              item_ID);
-gboolean      gimp_item_set_visible       (gint32              item_ID,
-                                           gboolean            visible);
-gboolean      gimp_item_get_linked        (gint32              item_ID);
-gboolean      gimp_item_set_linked        (gint32              item_ID,
-                                           gboolean            linked);
-gboolean      gimp_item_get_lock_content  (gint32              item_ID);
-gboolean      gimp_item_set_lock_content  (gint32              item_ID,
-                                           gboolean            lock_content);
-gboolean      gimp_item_get_lock_position (gint32              item_ID);
-gboolean      gimp_item_set_lock_position (gint32              item_ID,
-                                           gboolean            lock_position);
-GimpColorTag  gimp_item_get_color_tag     (gint32              item_ID);
-gboolean      gimp_item_set_color_tag     (gint32              item_ID,
-                                           GimpColorTag        color_tag);
-guint         gimp_item_get_tattoo        (gint32              item_ID);
-gboolean      gimp_item_set_tattoo        (gint32              item_ID,
-                                           guint               tattoo);
-gboolean      gimp_item_attach_parasite   (gint32              item_ID,
-                                           const GimpParasite *parasite);
-gboolean      gimp_item_detach_parasite   (gint32              item_ID,
-                                           const gchar        *name);
-GimpParasite* gimp_item_get_parasite      (gint32              item_ID,
-                                           const gchar        *name);
-gchar**       gimp_item_get_parasite_list (gint32              item_ID,
-                                           gint               *num_parasites);
+gboolean               gimp_item_is_valid          (gint32              item_ID);
+GimpImage*             gimp_item_get_image         (gint32              item_ID);
+GIMP_DEPRECATED_FOR(gimp_item_get_image)
+G_GNUC_INTERNAL gint32 _gimp_item_get_image        (gint32              item_ID);
+gboolean               gimp_item_delete            (gint32              item_ID);
+gboolean               gimp_item_is_drawable       (gint32              item_ID);
+gboolean               gimp_item_is_layer          (gint32              item_ID);
+gboolean               gimp_item_is_text_layer     (gint32              item_ID);
+gboolean               gimp_item_is_channel        (gint32              item_ID);
+gboolean               gimp_item_is_layer_mask     (gint32              item_ID);
+gboolean               gimp_item_is_selection      (gint32              item_ID);
+gboolean               gimp_item_is_vectors        (gint32              item_ID);
+gboolean               gimp_item_is_group          (gint32              item_ID);
+gint32                 gimp_item_get_parent        (gint32              item_ID);
+gint*                  gimp_item_get_children      (gint32              item_ID,
+                                                    gint               *num_children);
+gboolean               gimp_item_get_expanded      (gint32              item_ID);
+gboolean               gimp_item_set_expanded      (gint32              item_ID,
+                                                    gboolean            expanded);
+gchar*                 gimp_item_get_name          (gint32              item_ID);
+gboolean               gimp_item_set_name          (gint32              item_ID,
+                                                    const gchar        *name);
+gboolean               gimp_item_get_visible       (gint32              item_ID);
+gboolean               gimp_item_set_visible       (gint32              item_ID,
+                                                    gboolean            visible);
+gboolean               gimp_item_get_linked        (gint32              item_ID);
+gboolean               gimp_item_set_linked        (gint32              item_ID,
+                                                    gboolean            linked);
+gboolean               gimp_item_get_lock_content  (gint32              item_ID);
+gboolean               gimp_item_set_lock_content  (gint32              item_ID,
+                                                    gboolean            lock_content);
+gboolean               gimp_item_get_lock_position (gint32              item_ID);
+gboolean               gimp_item_set_lock_position (gint32              item_ID,
+                                                    gboolean            lock_position);
+GimpColorTag           gimp_item_get_color_tag     (gint32              item_ID);
+gboolean               gimp_item_set_color_tag     (gint32              item_ID,
+                                                    GimpColorTag        color_tag);
+guint                  gimp_item_get_tattoo        (gint32              item_ID);
+gboolean               gimp_item_set_tattoo        (gint32              item_ID,
+                                                    guint               tattoo);
+gboolean               gimp_item_attach_parasite   (gint32              item_ID,
+                                                    const GimpParasite *parasite);
+gboolean               gimp_item_detach_parasite   (gint32              item_ID,
+                                                    const gchar        *name);
+GimpParasite*          gimp_item_get_parasite      (gint32              item_ID,
+                                                    const gchar        *name);
+gchar**                gimp_item_get_parasite_list (gint32              item_ID,
+                                                    gint               *num_parasites);
 
 
 G_END_DECLS
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 2e8cae9208..01babe8e57 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -96,6 +96,68 @@ _gimp_layer_new (GimpImage     *image,
   return layer_ID;
 }
 
+/**
+ * __gimp_layer_new: (skip)
+ * @image_ID: The image to which to add the layer.
+ * @width: The layer width.
+ * @height: The layer height.
+ * @type: The layer type.
+ * @name: The layer name.
+ * @opacity: The layer opacity.
+ * @mode: The layer combination mode.
+ *
+ * Create a new layer.
+ *
+ * This procedure creates a new layer with the specified width, height,
+ * and type. Name, opacity, and mode are also supplied parameters. The
+ * new layer still needs to be added to the image, as this is not
+ * automatic. Add the new layer with the gimp_image_insert_layer()
+ * command. Other attributes such as layer mask modes, and offsets
+ * should be set with explicit procedure calls.
+ *
+ * Returns: The newly created layer.
+ **/
+gint32
+__gimp_layer_new (gint32         image_ID,
+                  gint           width,
+                  gint           height,
+                  GimpImageType  type,
+                  const gchar   *name,
+                  gdouble        opacity,
+                  GimpLayerMode  mode)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          GIMP_TYPE_IMAGE_TYPE, type,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_LAYER_MODE, mode,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
 /**
  * gimp_layer_new_from_visible:
  * @image: The source image from where the content is copied.
@@ -147,6 +209,57 @@ gimp_layer_new_from_visible (GimpImage   *image,
   return layer_ID;
 }
 
+/**
+ * _gimp_layer_new_from_visible: (skip)
+ * @image_ID: The source image from where the content is copied.
+ * @dest_image_ID: The destination image to which to add the layer.
+ * @name: The layer name.
+ *
+ * Create a new layer from what is visible in an image.
+ *
+ * This procedure creates a new layer from what is visible in the given
+ * image. The new layer still needs to be added to the destination
+ * image, as this is not automatic. Add the new layer with the
+ * gimp_image_insert_layer() command. Other attributes such as layer
+ * mask modes, and offsets should be set with explicit procedure calls.
+ *
+ * Returns: The newly created layer.
+ *
+ * Since: 2.6
+ **/
+gint32
+_gimp_layer_new_from_visible (gint32       image_ID,
+                              gint32       dest_image_ID,
+                              const gchar *name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_IMAGE_ID, dest_image_ID,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-new-from-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-new-from-visible",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
 /**
  * gimp_layer_new_from_drawable:
  * @drawable_ID: The source drawable from where the new layer is copied.
@@ -193,6 +306,52 @@ gimp_layer_new_from_drawable (gint32     drawable_ID,
   return layer_copy_ID;
 }
 
+/**
+ * _gimp_layer_new_from_drawable: (skip)
+ * @drawable_ID: The source drawable from where the new layer is copied.
+ * @dest_image_ID: The destination image to which to add the layer.
+ *
+ * Create a new layer by copying an existing drawable.
+ *
+ * This procedure creates a new layer as a copy of the specified
+ * drawable. The new layer still needs to be added to the image, as
+ * this is not automatic. Add the new layer with the
+ * gimp_image_insert_layer() command. Other attributes such as layer
+ * mask modes, and offsets should be set with explicit procedure calls.
+ *
+ * Returns: The newly copied layer.
+ **/
+gint32
+_gimp_layer_new_from_drawable (gint32 drawable_ID,
+                               gint32 dest_image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_copy_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_IMAGE_ID, dest_image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-new-from-drawable",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-new-from-drawable",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_copy_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_copy_ID;
+}
+
 /**
  * gimp_layer_group_new:
  * @image: The image to which to add the layer group.
@@ -240,6 +399,53 @@ gimp_layer_group_new (GimpImage *image)
   return layer_group_ID;
 }
 
+/**
+ * _gimp_layer_group_new: (skip)
+ * @image_ID: The image to which to add the layer group.
+ *
+ * Create a new layer group.
+ *
+ * This procedure creates a new layer group. Attributes such as layer
+ * mode and opacity should be set with explicit procedure calls. Add
+ * the new layer group (which is a kind of layer) with the
+ * gimp_image_insert_layer() command.
+ * Other procedures useful with layer groups:
+ * gimp_image_reorder_item(), gimp_item_get_parent(),
+ * gimp_item_get_children(), gimp_item_is_group().
+ *
+ * Returns: The newly created layer group.
+ *
+ * Since: 2.8
+ **/
+gint32
+_gimp_layer_group_new (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_group_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-group-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-group-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_group_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_group_ID;
+}
+
 /**
  * _gimp_layer_copy:
  * @layer_ID: The layer to copy.
diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h
index b46c48dac5..aad5f578fd 100644
--- a/libgimp/gimplayer_pdb.h
+++ b/libgimp/gimplayer_pdb.h
@@ -39,12 +39,29 @@ G_GNUC_INTERNAL gint32 _gimp_layer_new                 (GimpImage              *
                                                         const gchar            *name,
                                                         gdouble                 opacity,
                                                         GimpLayerMode           mode);
+GIMP_DEPRECATED_FOR(_gimp_layer_new)
+G_GNUC_INTERNAL gint32 __gimp_layer_new                (gint32                  image_ID,
+                                                        gint                    width,
+                                                        gint                    height,
+                                                        GimpImageType           type,
+                                                        const gchar            *name,
+                                                        gdouble                 opacity,
+                                                        GimpLayerMode           mode);
 gint32                 gimp_layer_new_from_visible     (GimpImage              *image,
                                                         GimpImage              *dest_image,
                                                         const gchar            *name);
+GIMP_DEPRECATED_FOR(gimp_layer_new_from_visible)
+G_GNUC_INTERNAL gint32 _gimp_layer_new_from_visible    (gint32                  image_ID,
+                                                        gint32                  dest_image_ID,
+                                                        const gchar            *name);
 gint32                 gimp_layer_new_from_drawable    (gint32                  drawable_ID,
                                                         GimpImage              *dest_image);
+GIMP_DEPRECATED_FOR(gimp_layer_new_from_drawable)
+G_GNUC_INTERNAL gint32 _gimp_layer_new_from_drawable   (gint32                  drawable_ID,
+                                                        gint32                  dest_image_ID);
 gint32                 gimp_layer_group_new            (GimpImage              *image);
+GIMP_DEPRECATED_FOR(gimp_layer_group_new)
+G_GNUC_INTERNAL gint32 _gimp_layer_group_new           (gint32                  image_ID);
 G_GNUC_INTERNAL gint32 _gimp_layer_copy                (gint32                  layer_ID,
                                                         gboolean                add_alpha);
 gboolean               gimp_layer_add_alpha            (gint32                  layer_ID);
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index 1f558a9baf..ff61666190 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -104,6 +104,76 @@ gimp_selection_bounds (GimpImage *image,
   return success;
 }
 
+/**
+ * _gimp_selection_bounds: (skip)
+ * @image_ID: The image.
+ * @non_empty: (out): TRUE if there is a selection.
+ * @x1: (out): x coordinate of upper left corner of selection bounds.
+ * @y1: (out): y coordinate of upper left corner of selection bounds.
+ * @x2: (out): x coordinate of lower right corner of selection bounds.
+ * @y2: (out): y coordinate of lower right corner of selection bounds.
+ *
+ * Find the bounding box of the current selection.
+ *
+ * This procedure returns whether there is a selection for the
+ * specified image. If there is one, the upper left and lower right
+ * corners of the bounding box are returned. These coordinates are
+ * relative to the image. Please note that the pixel specified by the
+ * lower right coordinate of the bounding box is not part of the
+ * selection. The selection ends at the upper left corner of this
+ * pixel. This means the width of the selection can be calculated as
+ * (x2 - x1), its height as (y2 - y1).
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_selection_bounds (gint32    image_ID,
+                        gboolean *non_empty,
+                        gint     *x1,
+                        gint     *y1,
+                        gint     *x2,
+                        gint     *y2)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-bounds",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-bounds",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *non_empty = FALSE;
+  *x1 = 0;
+  *y1 = 0;
+  *x2 = 0;
+  *y2 = 0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+      *x1 = g_value_get_int (gimp_value_array_index (return_vals, 2));
+      *y1 = g_value_get_int (gimp_value_array_index (return_vals, 3));
+      *x2 = g_value_get_int (gimp_value_array_index (return_vals, 4));
+      *y2 = g_value_get_int (gimp_value_array_index (return_vals, 5));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_selection_value:
  * @image: The image.
@@ -150,6 +220,52 @@ gimp_selection_value (GimpImage *image,
   return value;
 }
 
+/**
+ * _gimp_selection_value: (skip)
+ * @image_ID: The image.
+ * @x: x coordinate of value.
+ * @y: y coordinate of value.
+ *
+ * Find the value of the selection at the specified coordinates.
+ *
+ * This procedure returns the value of the selection at the specified
+ * coordinates. If the coordinates lie out of bounds, 0 is returned.
+ *
+ * Returns: Value of the selection.
+ **/
+gint
+_gimp_selection_value (gint32 image_ID,
+                       gint   x,
+                       gint   y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint value = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, x,
+                                          G_TYPE_INT, y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-value",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-value",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    value = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return value;
+}
+
 /**
  * gimp_selection_is_empty:
  * @image: The image.
@@ -190,6 +306,46 @@ gimp_selection_is_empty (GimpImage *image)
   return is_empty;
 }
 
+/**
+ * _gimp_selection_is_empty: (skip)
+ * @image_ID: The image.
+ *
+ * Determine whether the selection is empty.
+ *
+ * This procedure returns TRUE if the selection for the specified image
+ * is empty.
+ *
+ * Returns: Is the selection empty?
+ **/
+gboolean
+_gimp_selection_is_empty (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-is-empty",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-is-empty",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_empty;
+}
+
 /**
  * gimp_selection_translate:
  * @image: The image.
@@ -207,9 +363,386 @@ gimp_selection_is_empty (GimpImage *image)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_translate (GimpImage *image,
-                          gint       offx,
-                          gint       offy)
+gimp_selection_translate (GimpImage *image,
+                          gint       offx,
+                          gint       offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-translate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-translate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_selection_translate: (skip)
+ * @image_ID: The image.
+ * @offx: x offset for translation.
+ * @offy: y offset for translation.
+ *
+ * Translate the selection by the specified offsets.
+ *
+ * This procedure actually translates the selection for the specified
+ * image by the specified offsets. Regions that are translated from
+ * beyond the bounds of the image are set to empty. Valid regions of
+ * the selection which are translated beyond the bounds of the image
+ * because of this call are lost.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_selection_translate (gint32 image_ID,
+                           gint   offx,
+                           gint   offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-translate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-translate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_selection_float:
+ * @drawable_ID: The drawable from which to float selection.
+ * @offx: x offset for translation.
+ * @offy: y offset for translation.
+ *
+ * Float the selection from the specified drawable with initial offsets
+ * as specified.
+ *
+ * This procedure determines the region of the specified drawable that
+ * lies beneath the current selection. The region is then cut from the
+ * drawable and the resulting data is made into a new layer which is
+ * instantiated as a floating selection. The offsets allow initial
+ * positioning of the new floating selection.
+ *
+ * Returns: The floated layer.
+ **/
+gint32
+_gimp_selection_float (gint32 drawable_ID,
+                       gint   offx,
+                       gint   offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-float",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-float",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
+/**
+ * gimp_selection_invert:
+ * @image: The image.
+ *
+ * Invert the selection mask.
+ *
+ * This procedure inverts the selection mask. For every pixel in the
+ * selection channel, its new value is calculated as (255 - old-value).
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_selection_invert (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-invert",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-invert",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_selection_invert: (skip)
+ * @image_ID: The image.
+ *
+ * Invert the selection mask.
+ *
+ * This procedure inverts the selection mask. For every pixel in the
+ * selection channel, its new value is calculated as (255 - old-value).
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_selection_invert (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-invert",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-invert",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_selection_sharpen:
+ * @image: The image.
+ *
+ * Sharpen the selection mask.
+ *
+ * This procedure sharpens the selection mask. For every pixel in the
+ * selection channel, if the value is &gt; 127, the new pixel is
+ * assigned a value of 255. This removes any \"anti-aliasing\" that
+ * might exist in the selection mask's boundary.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_selection_sharpen (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-sharpen",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-sharpen",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_selection_sharpen: (skip)
+ * @image_ID: The image.
+ *
+ * Sharpen the selection mask.
+ *
+ * This procedure sharpens the selection mask. For every pixel in the
+ * selection channel, if the value is &gt; 127, the new pixel is
+ * assigned a value of 255. This removes any \"anti-aliasing\" that
+ * might exist in the selection mask's boundary.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_selection_sharpen (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-sharpen",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-sharpen",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_selection_all:
+ * @image: The image.
+ *
+ * Select all of the image.
+ *
+ * This procedure sets the selection mask to completely encompass the
+ * image. Every pixel in the selection channel is set to 255.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_selection_all (GimpImage *image)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-all",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-all",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_selection_all: (skip)
+ * @image_ID: The image.
+ *
+ * Select all of the image.
+ *
+ * This procedure sets the selection mask to completely encompass the
+ * image. Every pixel in the selection channel is set to 255.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_selection_all (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-all",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-all",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * gimp_selection_none:
+ * @image: The image.
+ *
+ * Deselect the entire image.
+ *
+ * This procedure deselects the entire image. Every pixel in the
+ * selection channel is set to 0.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_selection_none (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -218,16 +751,14 @@ gimp_selection_translate (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_INT, offx,
-                                          G_TYPE_INT, offy,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-translate",
+                                                "gimp-selection-none",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-translate",
+    return_vals = gimp_run_procedure_array ("gimp-selection-none",
                                             args);
   gimp_value_array_unref (args);
 
@@ -239,68 +770,59 @@ gimp_selection_translate (GimpImage *image,
 }
 
 /**
- * _gimp_selection_float:
- * @drawable_ID: The drawable from which to float selection.
- * @offx: x offset for translation.
- * @offy: y offset for translation.
+ * _gimp_selection_none: (skip)
+ * @image_ID: The image.
  *
- * Float the selection from the specified drawable with initial offsets
- * as specified.
+ * Deselect the entire image.
  *
- * This procedure determines the region of the specified drawable that
- * lies beneath the current selection. The region is then cut from the
- * drawable and the resulting data is made into a new layer which is
- * instantiated as a floating selection. The offsets allow initial
- * positioning of the new floating selection.
+ * This procedure deselects the entire image. Every pixel in the
+ * selection channel is set to 0.
  *
- * Returns: The floated layer.
+ * Returns: TRUE on success.
  **/
-gint32
-_gimp_selection_float (gint32 drawable_ID,
-                       gint   offx,
-                       gint   offy)
+gboolean
+_gimp_selection_none (gint32 image_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_INT, offx,
-                                          G_TYPE_INT, offy,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-float",
+                                                "gimp-selection-none",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-float",
+    return_vals = gimp_run_procedure_array ("gimp-selection-none",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return success;
 }
 
 /**
- * gimp_selection_invert:
+ * gimp_selection_feather:
  * @image: The image.
+ * @radius: Radius of feather (in pixels).
  *
- * Invert the selection mask.
+ * Feather the image's selection
  *
- * This procedure inverts the selection mask. For every pixel in the
- * selection channel, its new value is calculated as (255 - old-value).
+ * This procedure feathers the selection. Feathering is implemented
+ * using a gaussian blur.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_invert (GimpImage *image)
+gimp_selection_feather (GimpImage *image,
+                        gdouble    radius)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -309,14 +831,15 @@ gimp_selection_invert (GimpImage *image)
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_DOUBLE, radius,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-invert",
+                                                "gimp-selection-feather",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-invert",
+    return_vals = gimp_run_procedure_array ("gimp-selection-feather",
                                             args);
   gimp_value_array_unref (args);
 
@@ -328,20 +851,20 @@ gimp_selection_invert (GimpImage *image)
 }
 
 /**
- * gimp_selection_sharpen:
- * @image: The image.
+ * _gimp_selection_feather: (skip)
+ * @image_ID: The image.
+ * @radius: Radius of feather (in pixels).
  *
- * Sharpen the selection mask.
+ * Feather the image's selection
  *
- * This procedure sharpens the selection mask. For every pixel in the
- * selection channel, if the value is &gt; 127, the new pixel is
- * assigned a value of 255. This removes any \"anti-aliasing\" that
- * might exist in the selection mask's boundary.
+ * This procedure feathers the selection. Feathering is implemented
+ * using a gaussian blur.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_sharpen (GimpImage *image)
+_gimp_selection_feather (gint32  image_ID,
+                         gdouble radius)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -349,15 +872,16 @@ gimp_selection_sharpen (GimpImage *image)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, radius,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-sharpen",
+                                                "gimp-selection-feather",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-sharpen",
+    return_vals = gimp_run_procedure_array ("gimp-selection-feather",
                                             args);
   gimp_value_array_unref (args);
 
@@ -369,18 +893,21 @@ gimp_selection_sharpen (GimpImage *image)
 }
 
 /**
- * gimp_selection_all:
+ * gimp_selection_border:
  * @image: The image.
+ * @radius: Radius of border (in pixels).
  *
- * Select all of the image.
+ * Border the image's selection
  *
- * This procedure sets the selection mask to completely encompass the
- * image. Every pixel in the selection channel is set to 255.
+ * This procedure borders the selection. Bordering creates a new
+ * selection which is defined along the boundary of the previous
+ * selection at every point within the specified radius.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_all (GimpImage *image)
+gimp_selection_border (GimpImage *image,
+                       gint       radius)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -389,14 +916,15 @@ gimp_selection_all (GimpImage *image)
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          G_TYPE_INT, radius,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-all",
+                                                "gimp-selection-border",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-all",
+    return_vals = gimp_run_procedure_array ("gimp-selection-border",
                                             args);
   gimp_value_array_unref (args);
 
@@ -408,18 +936,21 @@ gimp_selection_all (GimpImage *image)
 }
 
 /**
- * gimp_selection_none:
- * @image: The image.
+ * _gimp_selection_border: (skip)
+ * @image_ID: The image.
+ * @radius: Radius of border (in pixels).
  *
- * Deselect the entire image.
+ * Border the image's selection
  *
- * This procedure deselects the entire image. Every pixel in the
- * selection channel is set to 0.
+ * This procedure borders the selection. Bordering creates a new
+ * selection which is defined along the boundary of the previous
+ * selection at every point within the specified radius.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_none (GimpImage *image)
+_gimp_selection_border (gint32 image_ID,
+                        gint   radius)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -427,15 +958,16 @@ gimp_selection_none (GimpImage *image)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, radius,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-none",
+                                                "gimp-selection-border",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-none",
+    return_vals = gimp_run_procedure_array ("gimp-selection-border",
                                             args);
   gimp_value_array_unref (args);
 
@@ -447,20 +979,20 @@ gimp_selection_none (GimpImage *image)
 }
 
 /**
- * gimp_selection_feather:
+ * gimp_selection_grow:
  * @image: The image.
- * @radius: Radius of feather (in pixels).
+ * @steps: Steps of grow (in pixels).
  *
- * Feather the image's selection
+ * Grow the image's selection
  *
- * This procedure feathers the selection. Feathering is implemented
- * using a gaussian blur.
+ * This procedure grows the selection. Growing involves expanding the
+ * boundary in all directions by the specified pixel amount.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_feather (GimpImage *image,
-                        gdouble    radius)
+gimp_selection_grow (GimpImage *image,
+                     gint       steps)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -469,15 +1001,15 @@ gimp_selection_feather (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_DOUBLE, radius,
+                                          G_TYPE_INT, steps,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-feather",
+                                                "gimp-selection-grow",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-feather",
+    return_vals = gimp_run_procedure_array ("gimp-selection-grow",
                                             args);
   gimp_value_array_unref (args);
 
@@ -489,21 +1021,20 @@ gimp_selection_feather (GimpImage *image,
 }
 
 /**
- * gimp_selection_border:
- * @image: The image.
- * @radius: Radius of border (in pixels).
+ * _gimp_selection_grow: (skip)
+ * @image_ID: The image.
+ * @steps: Steps of grow (in pixels).
  *
- * Border the image's selection
+ * Grow the image's selection
  *
- * This procedure borders the selection. Bordering creates a new
- * selection which is defined along the boundary of the previous
- * selection at every point within the specified radius.
+ * This procedure grows the selection. Growing involves expanding the
+ * boundary in all directions by the specified pixel amount.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_border (GimpImage *image,
-                       gint       radius)
+_gimp_selection_grow (gint32 image_ID,
+                      gint   steps)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -511,16 +1042,16 @@ gimp_selection_border (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          G_TYPE_INT, radius,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_INT, steps,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-border",
+                                                "gimp-selection-grow",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-border",
+    return_vals = gimp_run_procedure_array ("gimp-selection-grow",
                                             args);
   gimp_value_array_unref (args);
 
@@ -532,20 +1063,21 @@ gimp_selection_border (GimpImage *image,
 }
 
 /**
- * gimp_selection_grow:
+ * gimp_selection_shrink:
  * @image: The image.
- * @steps: Steps of grow (in pixels).
+ * @steps: Steps of shrink (in pixels).
  *
- * Grow the image's selection
+ * Shrink the image's selection
  *
- * This procedure grows the selection. Growing involves expanding the
- * boundary in all directions by the specified pixel amount.
+ * This procedure shrinks the selection. Shrinking involves trimming
+ * the existing selection boundary on all sides by the specified number
+ * of pixels.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_grow (GimpImage *image,
-                     gint       steps)
+gimp_selection_shrink (GimpImage *image,
+                       gint       steps)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -559,10 +1091,10 @@ gimp_selection_grow (GimpImage *image,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-grow",
+                                                "gimp-selection-shrink",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-selection-grow",
+    return_vals = gimp_run_procedure_array ("gimp-selection-shrink",
                                             args);
   gimp_value_array_unref (args);
 
@@ -574,8 +1106,8 @@ gimp_selection_grow (GimpImage *image,
 }
 
 /**
- * gimp_selection_shrink:
- * @image: The image.
+ * _gimp_selection_shrink: (skip)
+ * @image_ID: The image.
  * @steps: Steps of shrink (in pixels).
  *
  * Shrink the image's selection
@@ -587,8 +1119,8 @@ gimp_selection_grow (GimpImage *image,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_selection_shrink (GimpImage *image,
-                       gint       steps)
+_gimp_selection_shrink (gint32 image_ID,
+                        gint   steps)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -596,7 +1128,7 @@ gimp_selection_shrink (GimpImage *image,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_INT, steps,
                                           G_TYPE_NONE);
 
@@ -659,6 +1191,49 @@ gimp_selection_flood (GimpImage *image)
   return success;
 }
 
+/**
+ * _gimp_selection_flood: (skip)
+ * @image_ID: The image.
+ *
+ * Remove holes from the image's selection
+ *
+ * This procedure removes holes from the selection, that can come from
+ * selecting a patchy area with the Fuzzy Select Tool. In technical
+ * terms this procedure floods the selection. See the Algorithms page
+ * in the developer wiki for details.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_selection_flood (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-flood",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-flood",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_selection_save:
  * @image: The image.
@@ -699,3 +1274,44 @@ gimp_selection_save (GimpImage *image)
 
   return channel_ID;
 }
+
+/**
+ * _gimp_selection_save: (skip)
+ * @image_ID: The image.
+ *
+ * Copy the selection mask to a new channel.
+ *
+ * This procedure copies the selection mask and stores the content in a
+ * new channel. The new channel is automatically inserted into the
+ * image's list of channels.
+ *
+ * Returns: The new channel.
+ **/
+gint32
+_gimp_selection_save (gint32 image_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 channel_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-selection-save",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-selection-save",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return channel_ID;
+}
diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h
index 740f9c8e73..c42ac1cbaa 100644
--- a/libgimp/gimpselection_pdb.h
+++ b/libgimp/gimpselection_pdb.h
@@ -32,36 +32,77 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean               gimp_selection_bounds    (GimpImage *image,
-                                                 gboolean  *non_empty,
-                                                 gint      *x1,
-                                                 gint      *y1,
-                                                 gint      *x2,
-                                                 gint      *y2);
-gint                   gimp_selection_value     (GimpImage *image,
-                                                 gint       x,
-                                                 gint       y);
-gboolean               gimp_selection_is_empty  (GimpImage *image);
-gboolean               gimp_selection_translate (GimpImage *image,
-                                                 gint       offx,
-                                                 gint       offy);
-G_GNUC_INTERNAL gint32 _gimp_selection_float    (gint32     drawable_ID,
-                                                 gint       offx,
-                                                 gint       offy);
-gboolean               gimp_selection_invert    (GimpImage *image);
-gboolean               gimp_selection_sharpen   (GimpImage *image);
-gboolean               gimp_selection_all       (GimpImage *image);
-gboolean               gimp_selection_none      (GimpImage *image);
-gboolean               gimp_selection_feather   (GimpImage *image,
-                                                 gdouble    radius);
-gboolean               gimp_selection_border    (GimpImage *image,
-                                                 gint       radius);
-gboolean               gimp_selection_grow      (GimpImage *image,
-                                                 gint       steps);
-gboolean               gimp_selection_shrink    (GimpImage *image,
-                                                 gint       steps);
-gboolean               gimp_selection_flood     (GimpImage *image);
-gint32                 gimp_selection_save      (GimpImage *image);
+gboolean                 gimp_selection_bounds     (GimpImage *image,
+                                                    gboolean  *non_empty,
+                                                    gint      *x1,
+                                                    gint      *y1,
+                                                    gint      *x2,
+                                                    gint      *y2);
+GIMP_DEPRECATED_FOR(gimp_selection_bounds)
+G_GNUC_INTERNAL gboolean _gimp_selection_bounds    (gint32     image_ID,
+                                                    gboolean  *non_empty,
+                                                    gint      *x1,
+                                                    gint      *y1,
+                                                    gint      *x2,
+                                                    gint      *y2);
+gint                     gimp_selection_value      (GimpImage *image,
+                                                    gint       x,
+                                                    gint       y);
+GIMP_DEPRECATED_FOR(gimp_selection_value)
+G_GNUC_INTERNAL gint     _gimp_selection_value     (gint32     image_ID,
+                                                    gint       x,
+                                                    gint       y);
+gboolean                 gimp_selection_is_empty   (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_is_empty)
+G_GNUC_INTERNAL gboolean _gimp_selection_is_empty  (gint32     image_ID);
+gboolean                 gimp_selection_translate  (GimpImage *image,
+                                                    gint       offx,
+                                                    gint       offy);
+GIMP_DEPRECATED_FOR(gimp_selection_translate)
+G_GNUC_INTERNAL gboolean _gimp_selection_translate (gint32     image_ID,
+                                                    gint       offx,
+                                                    gint       offy);
+G_GNUC_INTERNAL gint32   _gimp_selection_float     (gint32     drawable_ID,
+                                                    gint       offx,
+                                                    gint       offy);
+gboolean                 gimp_selection_invert     (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_invert)
+G_GNUC_INTERNAL gboolean _gimp_selection_invert    (gint32     image_ID);
+gboolean                 gimp_selection_sharpen    (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_sharpen)
+G_GNUC_INTERNAL gboolean _gimp_selection_sharpen   (gint32     image_ID);
+gboolean                 gimp_selection_all        (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_all)
+G_GNUC_INTERNAL gboolean _gimp_selection_all       (gint32     image_ID);
+gboolean                 gimp_selection_none       (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_none)
+G_GNUC_INTERNAL gboolean _gimp_selection_none      (gint32     image_ID);
+gboolean                 gimp_selection_feather    (GimpImage *image,
+                                                    gdouble    radius);
+GIMP_DEPRECATED_FOR(gimp_selection_feather)
+G_GNUC_INTERNAL gboolean _gimp_selection_feather   (gint32     image_ID,
+                                                    gdouble    radius);
+gboolean                 gimp_selection_border     (GimpImage *image,
+                                                    gint       radius);
+GIMP_DEPRECATED_FOR(gimp_selection_border)
+G_GNUC_INTERNAL gboolean _gimp_selection_border    (gint32     image_ID,
+                                                    gint       radius);
+gboolean                 gimp_selection_grow       (GimpImage *image,
+                                                    gint       steps);
+GIMP_DEPRECATED_FOR(gimp_selection_grow)
+G_GNUC_INTERNAL gboolean _gimp_selection_grow      (gint32     image_ID,
+                                                    gint       steps);
+gboolean                 gimp_selection_shrink     (GimpImage *image,
+                                                    gint       steps);
+GIMP_DEPRECATED_FOR(gimp_selection_shrink)
+G_GNUC_INTERNAL gboolean _gimp_selection_shrink    (gint32     image_ID,
+                                                    gint       steps);
+gboolean                 gimp_selection_flood      (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_flood)
+G_GNUC_INTERNAL gboolean _gimp_selection_flood     (gint32     image_ID);
+gint32                   gimp_selection_save       (GimpImage *image);
+GIMP_DEPRECATED_FOR(gimp_selection_save)
+G_GNUC_INTERNAL gint32   _gimp_selection_save      (gint32     image_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index d3c937d1a6..c2082de921 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -92,6 +92,64 @@ gimp_text_layer_new (GimpImage   *image,
   return layer_ID;
 }
 
+/**
+ * _gimp_text_layer_new: (skip)
+ * @image_ID: The image.
+ * @text: The text to generate (in UTF-8 encoding).
+ * @fontname: The name of the font.
+ * @size: The size of text in either pixels or points.
+ * @unit: The units of specified size.
+ *
+ * Creates a new text layer.
+ *
+ * This procedure creates a new text layer. The arguments are kept as
+ * simple as necessary for the normal case. All text attributes,
+ * however, can be modified with the appropriate
+ * gimp_text_layer_set_*() procedures. The new layer still needs to be
+ * added to the image, as this is not automatic. Add the new layer
+ * using gimp_image_insert_layer().
+ *
+ * Returns: The new text layer.
+ *
+ * Since: 2.6
+ **/
+gint32
+_gimp_text_layer_new (gint32       image_ID,
+                      const gchar *text,
+                      const gchar *fontname,
+                      gdouble      size,
+                      GimpUnit     unit)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, text,
+                                          G_TYPE_STRING, fontname,
+                                          G_TYPE_DOUBLE, size,
+                                          GIMP_TYPE_UNIT, unit,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_ID;
+}
+
 /**
  * gimp_text_layer_get_text:
  * @layer_ID: The text layer.
diff --git a/libgimp/gimptextlayer_pdb.h b/libgimp/gimptextlayer_pdb.h
index da4be7f6e3..2ef1b94d2a 100644
--- a/libgimp/gimptextlayer_pdb.h
+++ b/libgimp/gimptextlayer_pdb.h
@@ -32,57 +32,63 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32                gimp_text_layer_new                (GimpImage             *image,
-                                                          const gchar           *text,
-                                                          const gchar           *fontname,
-                                                          gdouble                size,
-                                                          GimpUnit               unit);
-gchar*                gimp_text_layer_get_text           (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_text           (gint32                 layer_ID,
-                                                          const gchar           *text);
-gchar*                gimp_text_layer_get_markup         (gint32                 layer_ID);
-gchar*                gimp_text_layer_get_font           (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_font           (gint32                 layer_ID,
-                                                          const gchar           *font);
-gdouble               gimp_text_layer_get_font_size      (gint32                 layer_ID,
-                                                          GimpUnit              *unit);
-gboolean              gimp_text_layer_set_font_size      (gint32                 layer_ID,
-                                                          gdouble                font_size,
-                                                          GimpUnit               unit);
-gboolean              gimp_text_layer_get_antialias      (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_antialias      (gint32                 layer_ID,
-                                                          gboolean               antialias);
-GimpTextHintStyle     gimp_text_layer_get_hint_style     (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_hint_style     (gint32                 layer_ID,
-                                                          GimpTextHintStyle      style);
-gboolean              gimp_text_layer_get_kerning        (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_kerning        (gint32                 layer_ID,
-                                                          gboolean               kerning);
-gchar*                gimp_text_layer_get_language       (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_language       (gint32                 layer_ID,
-                                                          const gchar           *language);
-GimpTextDirection     gimp_text_layer_get_base_direction (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_base_direction (gint32                 layer_ID,
-                                                          GimpTextDirection      direction);
-GimpTextJustification gimp_text_layer_get_justification  (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_justification  (gint32                 layer_ID,
-                                                          GimpTextJustification  justify);
-gboolean              gimp_text_layer_get_color          (gint32                 layer_ID,
-                                                          GimpRGB               *color);
-gboolean              gimp_text_layer_set_color          (gint32                 layer_ID,
-                                                          const GimpRGB         *color);
-gdouble               gimp_text_layer_get_indent         (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_indent         (gint32                 layer_ID,
-                                                          gdouble                indent);
-gdouble               gimp_text_layer_get_line_spacing   (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_line_spacing   (gint32                 layer_ID,
-                                                          gdouble                line_spacing);
-gdouble               gimp_text_layer_get_letter_spacing (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_letter_spacing (gint32                 layer_ID,
-                                                          gdouble                letter_spacing);
-gboolean              gimp_text_layer_resize             (gint32                 layer_ID,
-                                                          gdouble                width,
-                                                          gdouble                height);
+gint32                 gimp_text_layer_new                (GimpImage             *image,
+                                                           const gchar           *text,
+                                                           const gchar           *fontname,
+                                                           gdouble                size,
+                                                           GimpUnit               unit);
+GIMP_DEPRECATED_FOR(gimp_text_layer_new)
+G_GNUC_INTERNAL gint32 _gimp_text_layer_new               (gint32                 image_ID,
+                                                           const gchar           *text,
+                                                           const gchar           *fontname,
+                                                           gdouble                size,
+                                                           GimpUnit               unit);
+gchar*                 gimp_text_layer_get_text           (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_text           (gint32                 layer_ID,
+                                                           const gchar           *text);
+gchar*                 gimp_text_layer_get_markup         (gint32                 layer_ID);
+gchar*                 gimp_text_layer_get_font           (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_font           (gint32                 layer_ID,
+                                                           const gchar           *font);
+gdouble                gimp_text_layer_get_font_size      (gint32                 layer_ID,
+                                                           GimpUnit              *unit);
+gboolean               gimp_text_layer_set_font_size      (gint32                 layer_ID,
+                                                           gdouble                font_size,
+                                                           GimpUnit               unit);
+gboolean               gimp_text_layer_get_antialias      (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_antialias      (gint32                 layer_ID,
+                                                           gboolean               antialias);
+GimpTextHintStyle      gimp_text_layer_get_hint_style     (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_hint_style     (gint32                 layer_ID,
+                                                           GimpTextHintStyle      style);
+gboolean               gimp_text_layer_get_kerning        (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_kerning        (gint32                 layer_ID,
+                                                           gboolean               kerning);
+gchar*                 gimp_text_layer_get_language       (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_language       (gint32                 layer_ID,
+                                                           const gchar           *language);
+GimpTextDirection      gimp_text_layer_get_base_direction (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_base_direction (gint32                 layer_ID,
+                                                           GimpTextDirection      direction);
+GimpTextJustification  gimp_text_layer_get_justification  (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_justification  (gint32                 layer_ID,
+                                                           GimpTextJustification  justify);
+gboolean               gimp_text_layer_get_color          (gint32                 layer_ID,
+                                                           GimpRGB               *color);
+gboolean               gimp_text_layer_set_color          (gint32                 layer_ID,
+                                                           const GimpRGB         *color);
+gdouble                gimp_text_layer_get_indent         (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_indent         (gint32                 layer_ID,
+                                                           gdouble                indent);
+gdouble                gimp_text_layer_get_line_spacing   (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_line_spacing   (gint32                 layer_ID,
+                                                           gdouble                line_spacing);
+gdouble                gimp_text_layer_get_letter_spacing (gint32                 layer_ID);
+gboolean               gimp_text_layer_set_letter_spacing (gint32                 layer_ID,
+                                                           gdouble                letter_spacing);
+gboolean               gimp_text_layer_resize             (gint32                 layer_ID,
+                                                           gdouble                width,
+                                                           gdouble                height);
 
 
 G_END_DECLS
diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c
index 041e1925f2..8777c5937c 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -113,6 +113,85 @@ gimp_text_fontname (GimpImage    *image,
   return text_layer_ID;
 }
 
+/**
+ * _gimp_text_fontname: (skip)
+ * @image_ID: The image.
+ * @drawable_ID: The affected drawable: (-1 for a new text layer).
+ * @x: The x coordinate for the left of the text bounding box.
+ * @y: The y coordinate for the top of the text bounding box.
+ * @text: The text to generate (in UTF-8 encoding).
+ * @border: The size of the border.
+ * @antialias: Antialiasing.
+ * @size: The size of text in either pixels or points.
+ * @size_type: The units of specified size.
+ * @fontname: The name of the font.
+ *
+ * Add text at the specified location as a floating selection or a new
+ * layer.
+ *
+ * This tool requires a fontname matching an installed PangoFT2 font.
+ * You can specify the fontsize in units of pixels or points, and the
+ * appropriate metric is specified using the size_type argument. The x
+ * and y parameters together control the placement of the new text by
+ * specifying the upper left corner of the text bounding box. If the
+ * specified drawable parameter is valid, the text will be created as a
+ * floating selection attached to the drawable. If the drawable
+ * parameter is not valid (-1), the text will appear as a new layer.
+ * Finally, a border can be specified around the final rendered text.
+ * The border is measured in pixels. Parameter size-type is not used
+ * and is currently ignored. If you need to display a font in points,
+ * divide the size in points by 72.0 and multiply it by the image's
+ * vertical resolution.
+ *
+ * Returns: The new text layer or -1 if no layer was created.
+ **/
+gint32
+_gimp_text_fontname (gint32        image_ID,
+                     gint32        drawable_ID,
+                     gdouble       x,
+                     gdouble       y,
+                     const gchar  *text,
+                     gint          border,
+                     gboolean      antialias,
+                     gdouble       size,
+                     GimpSizeType  size_type,
+                     const gchar  *fontname)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 text_layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_STRING, text,
+                                          G_TYPE_INT, border,
+                                          G_TYPE_BOOLEAN, antialias,
+                                          G_TYPE_DOUBLE, size,
+                                          GIMP_TYPE_SIZE_TYPE, size_type,
+                                          G_TYPE_STRING, fontname,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-fontname",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-fontname",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    text_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return text_layer_ID;
+}
+
 /**
  * gimp_text_get_extents_fontname:
  * @text: The text to generate (in UTF-8 encoding).
diff --git a/libgimp/gimptexttool_pdb.h b/libgimp/gimptexttool_pdb.h
index cc3b6ab7f7..46a8fdc2ea 100644
--- a/libgimp/gimptexttool_pdb.h
+++ b/libgimp/gimptexttool_pdb.h
@@ -32,24 +32,35 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32   gimp_text_fontname             (GimpImage    *image,
-                                         gint32        drawable_ID,
-                                         gdouble       x,
-                                         gdouble       y,
-                                         const gchar  *text,
-                                         gint          border,
-                                         gboolean      antialias,
-                                         gdouble       size,
-                                         GimpSizeType  size_type,
-                                         const gchar  *fontname);
-gboolean gimp_text_get_extents_fontname (const gchar  *text,
-                                         gdouble       size,
-                                         GimpSizeType  size_type,
-                                         const gchar  *fontname,
-                                         gint         *width,
-                                         gint         *height,
-                                         gint         *ascent,
-                                         gint         *descent);
+gint32                 gimp_text_fontname             (GimpImage    *image,
+                                                       gint32        drawable_ID,
+                                                       gdouble       x,
+                                                       gdouble       y,
+                                                       const gchar  *text,
+                                                       gint          border,
+                                                       gboolean      antialias,
+                                                       gdouble       size,
+                                                       GimpSizeType  size_type,
+                                                       const gchar  *fontname);
+GIMP_DEPRECATED_FOR(gimp_text_fontname)
+G_GNUC_INTERNAL gint32 _gimp_text_fontname            (gint32        image_ID,
+                                                       gint32        drawable_ID,
+                                                       gdouble       x,
+                                                       gdouble       y,
+                                                       const gchar  *text,
+                                                       gint          border,
+                                                       gboolean      antialias,
+                                                       gdouble       size,
+                                                       GimpSizeType  size_type,
+                                                       const gchar  *fontname);
+gboolean               gimp_text_get_extents_fontname (const gchar  *text,
+                                                       gdouble       size,
+                                                       GimpSizeType  size_type,
+                                                       const gchar  *fontname,
+                                                       gint         *width,
+                                                       gint         *height,
+                                                       gint         *ascent,
+                                                       gint         *descent);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index f68da7e754..3f3a6c7499 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -79,6 +79,51 @@ gimp_vectors_new (GimpImage   *image,
   return vectors_ID;
 }
 
+/**
+ * _gimp_vectors_new: (skip)
+ * @image_ID: The image.
+ * @name: the name of the new vector object.
+ *
+ * Creates a new empty vectors object.
+ *
+ * Creates a new empty vectors object. The vectors object needs to be
+ * added to the image using gimp_image_insert_vectors().
+ *
+ * Returns: the current vector object, 0 if no vector exists in the image.
+ *
+ * Since: 2.4
+ **/
+gint32
+_gimp_vectors_new (gint32       image_ID,
+                   const gchar *name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 vectors_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-new",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-new",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return vectors_ID;
+}
+
 /**
  * gimp_vectors_new_from_text_layer:
  * @image: The image.
@@ -124,6 +169,51 @@ gimp_vectors_new_from_text_layer (GimpImage *image,
   return vectors_ID;
 }
 
+/**
+ * _gimp_vectors_new_from_text_layer: (skip)
+ * @image_ID: The image.
+ * @layer_ID: The text layer.
+ *
+ * Creates a new vectors object from a text layer.
+ *
+ * Creates a new vectors object from a text layer. The vectors object
+ * needs to be added to the image using gimp_image_insert_vectors().
+ *
+ * Returns: The vectors of the text layer.
+ *
+ * Since: 2.6
+ **/
+gint32
+_gimp_vectors_new_from_text_layer (gint32 image_ID,
+                                   gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 vectors_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-new-from-text-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-new-from-text-layer",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return vectors_ID;
+}
+
 /**
  * gimp_vectors_copy:
  * @vectors_ID: The vectors object to copy.
@@ -1194,6 +1284,69 @@ gimp_vectors_import_from_file (GimpImage    *image,
   return success;
 }
 
+/**
+ * _gimp_vectors_import_from_file: (skip)
+ * @image_ID: The image.
+ * @filename: The name of the SVG file to import.
+ * @merge: Merge paths into a single vectors object.
+ * @scale: Scale the SVG to image dimensions.
+ * @num_vectors: (out): The number of newly created vectors.
+ * @vectors_ids: (out) (array length=num_vectors): The list of newly created vectors.
+ *
+ * Import paths from an SVG file.
+ *
+ * This procedure imports paths from an SVG file. SVG elements other
+ * than paths and basic shapes are ignored.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_vectors_import_from_file (gint32        image_ID,
+                                const gchar  *filename,
+                                gboolean      merge,
+                                gboolean      scale,
+                                gint         *num_vectors,
+                                gint        **vectors_ids)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_BOOLEAN, merge,
+                                          G_TYPE_BOOLEAN, scale,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-import-from-file",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-file",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_vectors = 0;
+  *vectors_ids = NULL;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_vectors_import_from_string:
  * @image: The image.
@@ -1261,6 +1414,73 @@ gimp_vectors_import_from_string (GimpImage    *image,
   return success;
 }
 
+/**
+ * _gimp_vectors_import_from_string: (skip)
+ * @image_ID: The image.
+ * @string: A string that must be a complete and valid SVG document.
+ * @length: Number of bytes in string or -1 if the string is NULL terminated.
+ * @merge: Merge paths into a single vectors object.
+ * @scale: Scale the SVG to image dimensions.
+ * @num_vectors: (out): The number of newly created vectors.
+ * @vectors_ids: (out) (array length=num_vectors): The list of newly created vectors.
+ *
+ * Import paths from an SVG string.
+ *
+ * This procedure works like gimp_vectors_import_from_file() but takes
+ * a string rather than reading the SVG from a file. This allows you to
+ * write scripts that generate SVG and feed it to GIMP.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_vectors_import_from_string (gint32        image_ID,
+                                  const gchar  *string,
+                                  gint          length,
+                                  gboolean      merge,
+                                  gboolean      scale,
+                                  gint         *num_vectors,
+                                  gint        **vectors_ids)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, string,
+                                          G_TYPE_INT, length,
+                                          G_TYPE_BOOLEAN, merge,
+                                          G_TYPE_BOOLEAN, scale,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-import-from-string",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-string",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_vectors = 0;
+  *vectors_ids = NULL;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_vectors_export_to_file:
  * @image: The image.
@@ -1310,6 +1530,55 @@ gimp_vectors_export_to_file (GimpImage   *image,
   return success;
 }
 
+/**
+ * _gimp_vectors_export_to_file: (skip)
+ * @image_ID: The image.
+ * @filename: The name of the SVG file to create.
+ * @vectors_ID: The vectors object to be saved, or 0 for all in the image.
+ *
+ * save a path as an SVG file.
+ *
+ * This procedure creates an SVG file to save a Vectors object, that
+ * is, a path. The resulting file can be edited using a vector graphics
+ * application, or later reloaded into GIMP. If you pass 0 as the
+ * 'vectors' argument, then all paths in the image will be exported.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_vectors_export_to_file (gint32       image_ID,
+                              const gchar *filename,
+                              gint32       vectors_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-export-to-file",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-file",
+                                            args);
+  gimp_value_array_unref (args);
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
 /**
  * gimp_vectors_export_to_string:
  * @image: The image.
@@ -1358,3 +1627,51 @@ gimp_vectors_export_to_string (GimpImage *image,
 
   return string;
 }
+
+/**
+ * _gimp_vectors_export_to_string: (skip)
+ * @image_ID: The image.
+ * @vectors_ID: The vectors object to save, or 0 for all in the image.
+ *
+ * Save a path as an SVG string.
+ *
+ * This procedure works like gimp_vectors_export_to_file() but creates
+ * a string rather than a file. The contents are a NUL-terminated
+ * string that holds a complete XML document. If you pass 0 as the
+ * 'vectors' argument, then all paths in the image will be exported.
+ *
+ * Returns: A string whose contents are a complete SVG document.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.6
+ **/
+gchar *
+_gimp_vectors_export_to_string (gint32 image_ID,
+                                gint32 vectors_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *string = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-vectors-export-to-string",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-string",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return string;
+}
diff --git a/libgimp/gimpvectors_pdb.h b/libgimp/gimpvectors_pdb.h
index 27c6719f8e..18cfc9fc73 100644
--- a/libgimp/gimpvectors_pdb.h
+++ b/libgimp/gimpvectors_pdb.h
@@ -32,111 +32,139 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32                gimp_vectors_new                       (GimpImage              *image,
-                                                              const gchar            *name);
-gint32                gimp_vectors_new_from_text_layer       (GimpImage              *image,
-                                                              gint32                  layer_ID);
-gint32                gimp_vectors_copy                      (gint32                  vectors_ID);
-gint*                 gimp_vectors_get_strokes               (gint32                  vectors_ID,
-                                                              gint                   *num_strokes);
-gdouble               gimp_vectors_stroke_get_length         (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 precision);
-gboolean              gimp_vectors_stroke_get_point_at_dist  (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 dist,
-                                                              gdouble                 precision,
-                                                              gdouble                *x_point,
-                                                              gdouble                *y_point,
-                                                              gdouble                *slope,
-                                                              gboolean               *valid);
-gboolean              gimp_vectors_remove_stroke             (gint32                  vectors_ID,
-                                                              gint                    stroke_id);
-gboolean              gimp_vectors_stroke_close              (gint32                  vectors_ID,
-                                                              gint                    stroke_id);
-gboolean              gimp_vectors_stroke_translate          (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gint                    off_x,
-                                                              gint                    off_y);
-gboolean              gimp_vectors_stroke_scale              (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 scale_x,
-                                                              gdouble                 scale_y);
-gboolean              gimp_vectors_stroke_rotate             (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 center_x,
-                                                              gdouble                 center_y,
-                                                              gdouble                 angle);
-gboolean              gimp_vectors_stroke_flip               (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              GimpOrientationType     flip_type,
-                                                              gdouble                 axis);
-gboolean              gimp_vectors_stroke_flip_free          (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 x1,
-                                                              gdouble                 y1,
-                                                              gdouble                 x2,
-                                                              gdouble                 y2);
-GimpVectorsStrokeType gimp_vectors_stroke_get_points         (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gint                   *num_points,
-                                                              gdouble               **controlpoints,
-                                                              gboolean               *closed);
-gint                  gimp_vectors_stroke_new_from_points    (gint32                  vectors_ID,
-                                                              GimpVectorsStrokeType   type,
-                                                              gint                    num_points,
-                                                              const gdouble          *controlpoints,
-                                                              gboolean                closed);
-gdouble*              gimp_vectors_stroke_interpolate        (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 precision,
-                                                              gint                   *num_coords,
-                                                              gboolean               *closed);
-gint                  gimp_vectors_bezier_stroke_new_moveto  (gint32                  vectors_ID,
-                                                              gdouble                 x0,
-                                                              gdouble                 y0);
-gboolean              gimp_vectors_bezier_stroke_lineto      (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 x0,
-                                                              gdouble                 y0);
-gboolean              gimp_vectors_bezier_stroke_conicto     (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 x0,
-                                                              gdouble                 y0,
-                                                              gdouble                 x1,
-                                                              gdouble                 y1);
-gboolean              gimp_vectors_bezier_stroke_cubicto     (gint32                  vectors_ID,
-                                                              gint                    stroke_id,
-                                                              gdouble                 x0,
-                                                              gdouble                 y0,
-                                                              gdouble                 x1,
-                                                              gdouble                 y1,
-                                                              gdouble                 x2,
-                                                              gdouble                 y2);
-gint                  gimp_vectors_bezier_stroke_new_ellipse (gint32                  vectors_ID,
-                                                              gdouble                 x0,
-                                                              gdouble                 y0,
-                                                              gdouble                 radius_x,
-                                                              gdouble                 radius_y,
-                                                              gdouble                 angle);
-gboolean              gimp_vectors_import_from_file          (GimpImage              *image,
-                                                              const gchar            *filename,
-                                                              gboolean                merge,
-                                                              gboolean                scale,
-                                                              gint                   *num_vectors,
-                                                              gint                  **vectors_ids);
-gboolean              gimp_vectors_import_from_string        (GimpImage              *image,
-                                                              const gchar            *string,
-                                                              gint                    length,
-                                                              gboolean                merge,
-                                                              gboolean                scale,
-                                                              gint                   *num_vectors,
-                                                              gint                  **vectors_ids);
-gboolean              gimp_vectors_export_to_file            (GimpImage              *image,
-                                                              const gchar            *filename,
-                                                              gint32                  vectors_ID);
-gchar*                gimp_vectors_export_to_string          (GimpImage              *image,
-                                                              gint32                  vectors_ID);
+gint32                   gimp_vectors_new                       (GimpImage              *image,
+                                                                 const gchar            *name);
+GIMP_DEPRECATED_FOR(gimp_vectors_new)
+G_GNUC_INTERNAL gint32   _gimp_vectors_new                      (gint32                  image_ID,
+                                                                 const gchar            *name);
+gint32                   gimp_vectors_new_from_text_layer       (GimpImage              *image,
+                                                                 gint32                  layer_ID);
+GIMP_DEPRECATED_FOR(gimp_vectors_new_from_text_layer)
+G_GNUC_INTERNAL gint32   _gimp_vectors_new_from_text_layer      (gint32                  image_ID,
+                                                                 gint32                  layer_ID);
+gint32                   gimp_vectors_copy                      (gint32                  vectors_ID);
+gint*                    gimp_vectors_get_strokes               (gint32                  vectors_ID,
+                                                                 gint                   *num_strokes);
+gdouble                  gimp_vectors_stroke_get_length         (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 precision);
+gboolean                 gimp_vectors_stroke_get_point_at_dist  (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 dist,
+                                                                 gdouble                 precision,
+                                                                 gdouble                *x_point,
+                                                                 gdouble                *y_point,
+                                                                 gdouble                *slope,
+                                                                 gboolean               *valid);
+gboolean                 gimp_vectors_remove_stroke             (gint32                  vectors_ID,
+                                                                 gint                    stroke_id);
+gboolean                 gimp_vectors_stroke_close              (gint32                  vectors_ID,
+                                                                 gint                    stroke_id);
+gboolean                 gimp_vectors_stroke_translate          (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gint                    off_x,
+                                                                 gint                    off_y);
+gboolean                 gimp_vectors_stroke_scale              (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 scale_x,
+                                                                 gdouble                 scale_y);
+gboolean                 gimp_vectors_stroke_rotate             (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 center_x,
+                                                                 gdouble                 center_y,
+                                                                 gdouble                 angle);
+gboolean                 gimp_vectors_stroke_flip               (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 GimpOrientationType     flip_type,
+                                                                 gdouble                 axis);
+gboolean                 gimp_vectors_stroke_flip_free          (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 x1,
+                                                                 gdouble                 y1,
+                                                                 gdouble                 x2,
+                                                                 gdouble                 y2);
+GimpVectorsStrokeType    gimp_vectors_stroke_get_points         (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gint                   *num_points,
+                                                                 gdouble               **controlpoints,
+                                                                 gboolean               *closed);
+gint                     gimp_vectors_stroke_new_from_points    (gint32                  vectors_ID,
+                                                                 GimpVectorsStrokeType   type,
+                                                                 gint                    num_points,
+                                                                 const gdouble          *controlpoints,
+                                                                 gboolean                closed);
+gdouble*                 gimp_vectors_stroke_interpolate        (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 precision,
+                                                                 gint                   *num_coords,
+                                                                 gboolean               *closed);
+gint                     gimp_vectors_bezier_stroke_new_moveto  (gint32                  vectors_ID,
+                                                                 gdouble                 x0,
+                                                                 gdouble                 y0);
+gboolean                 gimp_vectors_bezier_stroke_lineto      (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 x0,
+                                                                 gdouble                 y0);
+gboolean                 gimp_vectors_bezier_stroke_conicto     (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 x0,
+                                                                 gdouble                 y0,
+                                                                 gdouble                 x1,
+                                                                 gdouble                 y1);
+gboolean                 gimp_vectors_bezier_stroke_cubicto     (gint32                  vectors_ID,
+                                                                 gint                    stroke_id,
+                                                                 gdouble                 x0,
+                                                                 gdouble                 y0,
+                                                                 gdouble                 x1,
+                                                                 gdouble                 y1,
+                                                                 gdouble                 x2,
+                                                                 gdouble                 y2);
+gint                     gimp_vectors_bezier_stroke_new_ellipse (gint32                  vectors_ID,
+                                                                 gdouble                 x0,
+                                                                 gdouble                 y0,
+                                                                 gdouble                 radius_x,
+                                                                 gdouble                 radius_y,
+                                                                 gdouble                 angle);
+gboolean                 gimp_vectors_import_from_file          (GimpImage              *image,
+                                                                 const gchar            *filename,
+                                                                 gboolean                merge,
+                                                                 gboolean                scale,
+                                                                 gint                   *num_vectors,
+                                                                 gint                  **vectors_ids);
+GIMP_DEPRECATED_FOR(gimp_vectors_import_from_file)
+G_GNUC_INTERNAL gboolean _gimp_vectors_import_from_file         (gint32                  image_ID,
+                                                                 const gchar            *filename,
+                                                                 gboolean                merge,
+                                                                 gboolean                scale,
+                                                                 gint                   *num_vectors,
+                                                                 gint                  **vectors_ids);
+gboolean                 gimp_vectors_import_from_string        (GimpImage              *image,
+                                                                 const gchar            *string,
+                                                                 gint                    length,
+                                                                 gboolean                merge,
+                                                                 gboolean                scale,
+                                                                 gint                   *num_vectors,
+                                                                 gint                  **vectors_ids);
+GIMP_DEPRECATED_FOR(gimp_vectors_import_from_string)
+G_GNUC_INTERNAL gboolean _gimp_vectors_import_from_string       (gint32                  image_ID,
+                                                                 const gchar            *string,
+                                                                 gint                    length,
+                                                                 gboolean                merge,
+                                                                 gboolean                scale,
+                                                                 gint                   *num_vectors,
+                                                                 gint                  **vectors_ids);
+gboolean                 gimp_vectors_export_to_file            (GimpImage              *image,
+                                                                 const gchar            *filename,
+                                                                 gint32                  vectors_ID);
+GIMP_DEPRECATED_FOR(gimp_vectors_export_to_file)
+G_GNUC_INTERNAL gboolean _gimp_vectors_export_to_file           (gint32                  image_ID,
+                                                                 const gchar            *filename,
+                                                                 gint32                  vectors_ID);
+gchar*                   gimp_vectors_export_to_string          (GimpImage              *image,
+                                                                 gint32                  vectors_ID);
+GIMP_DEPRECATED_FOR(gimp_vectors_export_to_string)
+G_GNUC_INTERNAL gchar*   _gimp_vectors_export_to_string         (gint32                  image_ID,
+                                                                 gint32                  vectors_ID);
 
 
 G_END_DECLS
diff --git a/pdb/lib.pl b/pdb/lib.pl
index 8dda2e79c5..c76b7c8c87 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -45,17 +45,23 @@ sub desc_wrap {
     return $wrapped;
 }
 
-sub generate {
-    my @procs = @{(shift)};
-    my %out;
+sub generate_fun {
+    my ($proc, $out, $api_deprecated) = @_;
+    my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs});
+    my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs});
 
     sub libtype {
        my $arg = shift;
        my $outarg = shift;
+       my $api_deprecated = shift;
        my ($type, $name) = &arg_parse($arg->{type});
        my $argtype = $arg_types{$type};
        my $rettype = '';
-       
+
+        if ($api_deprecated && $argtype->{name} eq 'IMAGE') {
+            return 'gint32 ';
+        }
+
        if (exists $argtype->{id}) {
            return 'gint32 ';
        }
@@ -73,371 +79,393 @@ sub generate {
            }
            $rettype .= $argtype->{const_type};
        }
-       
+
        $rettype =~ s/int32/int/ unless exists $arg->{keep_size};
        $rettype .= '*' if exists $argtype->{struct};
        return $rettype;
     }
 
-    foreach $name (@procs) {
-       my $proc = $main::pdb{$name};
-       my $out = \%{$out{$proc->{group}}};
-
-       my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs});
-       my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs});
-
-       my $funcname = "gimp_$name";
-       my $wrapped = "";
-       my %usednames;
-       my $retdesc = " * Returns:";
-
-       if ($proc->{lib_private}) {
-           $wrapped = '_';
-       }
+    my $funcname = "gimp_$name";
+    my $wrapped = "";
+    my %usednames;
+    my $retdesc = " * Returns:";
+    my $func_annotations = "";
 
-       if ($proc->{deprecated}) {
-           if ($proc->{deprecated} eq 'NONE') {
-               push @{$out->{protos}}, "GIMP_DEPRECATED\n";
-           }
-           else {
-               my $underscores = $proc->{deprecated};
-               $underscores =~ s/-/_/g;
-
-               push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($underscores)\n";
-           }
-       }
-
-       # Find the return argument (defaults to the first arg if not
-       # explicitly set
-       my $retarg  = undef;
-       $retvoid = 0;
-       foreach (@outargs) {
-           $retarg = $_, last if exists $_->{retval};
-       }
+    if ($proc->{lib_private}) {
+        $wrapped = '_';
+    }
 
-       unless ($retarg) {
-           if (scalar @outargs) {
-               if (exists $outargs[0]->{void_ret}) {
-                   $retvoid = 1;
-               }
-               else {
-                   $retarg = exists $outargs[0]->{num} ? $outargs[1]
-                                                       : $outargs[0];
-               }
-           }
-       }
+    if ($api_deprecated) {
+        push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($wrapped$funcname)\n";
+        $func_annotations .= " (skip)";
+    }
+    elsif ($proc->{deprecated}) {
+        if ($proc->{deprecated} eq 'NONE') {
+            push @{$out->{protos}}, "GIMP_DEPRECATED\n";
+        }
+        else {
+            my $underscores = $proc->{deprecated};
+            $underscores =~ s/-/_/g;
 
-       my $rettype;
-       if ($retarg) {
-           my ($type) = &arg_parse($retarg->{type});
-           my $argtype = $arg_types{$type};
-           my $annotate = "";
-           $rettype = &libtype($retarg, 1);
-           chop $rettype unless $rettype =~ /\*$/;
+            push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($underscores)\n";
+        }
+    }
 
-           $retarg->{retval} = 1;
+    # Add an underscore for deprecated API. If the original was already
+    # private, this will be 2 underscores.
+    if ($api_deprecated) {
+        $wrapped .= '_';
+    }
 
-           if (exists $argtype->{array}) {
-               $annotate = " (array length=$retarg->{array}->{name})";
-           }
+    # Find the return argument (defaults to the first arg if not
+    # explicitly set
+    my $retarg  = undef;
+    $retvoid = 0;
+    foreach (@outargs) {
+        $retarg = $_, last if exists $_->{retval};
+    }
 
-           if (exists $argtype->{out_annotate}) {
-               $annotate .= " $argtype->{out_annotate}";
-           }
+    unless ($retarg) {
+        if (scalar @outargs) {
+            if (exists $outargs[0]->{void_ret}) {
+                $retvoid = 1;
+            }
+            else {
+                $retarg = exists $outargs[0]->{num} ? $outargs[1]
+                                                    : $outargs[0];
+            }
+        }
+    }
 
-           if ($annotate eq "") {
-               $retdesc .= " $retarg->{desc}";
-           }
-           else {
-               if (exists $retarg->{desc}) {
-                   if ((length ($annotate) +
-                        length ($retarg->{desc})) > 65) {
-                       $retdesc .= $annotate . ":\n *          " . $retarg->{desc};
-                   }
-                   else {
-                       $retdesc .= $annotate . ": " . $retarg->{desc};
-                   }
-               }
-           }
+    my $rettype;
+    if ($retarg) {
+        my ($type) = &arg_parse($retarg->{type});
+        my $argtype = $arg_types{$type};
+        my $annotate = "";
+        $rettype = &libtype($retarg, 1, $api_deprecated);
+        chop $rettype unless $rettype =~ /\*$/;
 
-           unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' }
+        $retarg->{retval} = 1;
 
-           if ($retarg->{type} eq 'string') {
-               $retdesc .= "\n *          The returned value must be freed with g_free().";
-           }
-           elsif ($retarg->{type} eq 'stringarray') {
-               $retdesc .= "\n *          The returned value must be freed with g_strfreev().";
-           }
-           elsif ($retarg->{type} eq 'param') {
-               $retdesc .= "\n *          The returned value must be freed with g_param_spec_unref().";
-           }
-           elsif (exists $argtype->{array}) {
-               $retdesc .= "\n *          The returned value must be freed with g_free().";
-           }
-       }
-       else {
-           # No return values
-           $rettype = 'void';
-       }
+        if (exists $argtype->{array}) {
+            $annotate = " (array length=$retarg->{array}->{name})";
+        }
 
-       # The parameters to the function
-       my $arglist = "";
-       my $argdesc = "";
-       my $sincedesc = "";
-       my $value_array = "";
-       my $arg_array = "";
-       my $argc = 0;
-       foreach (@inargs) {
-           my ($type, @typeinfo) = &arg_parse($_->{type});
-           my $arg = $arg_types{$type};
-           my $var = $_->{name};
-           my $desc = exists $_->{desc} ? $_->{desc} : "";
-           my $var_len;
-           my $value;
-
-           $var .= '_ID' if $arg->{id};
-
-           # This gets passed to gimp_value_array_new_with_types()
-           if ($type eq 'enum') {
-               $enum_type = $typeinfo[0];
-               $enum_type =~ s/([a-z])([A-Z])/$1_$2/g;
-               $enum_type =~ s/([A-Z]+)([A-Z])/$1_$2/g;
-               $enum_type =~ tr/[a-z]/[A-Z]/;
-               $enum_type =~ s/^GIMP/GIMP_TYPE/;
-               $enum_type =~ s/^GEGL/GEGL_TYPE/;
-
-               $value_array .= "$enum_type, ";
-           }
-           else {
-               $value_array .= "$arg->{gtype}, ";
-           }
+        if ($api_deprecated) {
+            if (exists $argtype->{out_annotate_d}) {
+                $annotate .= " $argtype->{out_annotate_d}";
+            }
+        }
+        elsif (exists $argtype->{out_annotate}) {
+            $annotate .= " $argtype->{out_annotate}";
+        }
 
-           if (exists $_->{array}) {
-               $value_array .= "NULL";
-           }
-           elsif (exists $arg->{convert_func}) {
-               $value_array .= eval qq/"$arg->{convert_func}"/;
+        if ($annotate eq "") {
+            $retdesc .= " $retarg->{desc}";
+        }
+        else {
+            if (exists $retarg->{desc}) {
+                if ((length ($annotate) +
+                     length ($retarg->{desc})) > 65) {
+                    $retdesc .= $annotate . ":\n *          " . $retarg->{desc};
+                }
+                else {
+                    $retdesc .= $annotate . ": " . $retarg->{desc};
+                }
             }
-           else {
-               $value_array .= "$var";
-           }
+        }
 
-           $value_array .= ",\n" . " " x 42;
+        unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' }
 
-           if (exists $_->{array}) {
-               my $arrayarg = $_->{array};
+        if ($retarg->{type} eq 'string') {
+            $retdesc .= "\n *          The returned value must be freed with g_free().";
+        }
+        elsif ($retarg->{type} eq 'stringarray') {
+            $retdesc .= "\n *          The returned value must be freed with g_strfreev().";
+        }
+        elsif ($retarg->{type} eq 'param') {
+            $retdesc .= "\n *          The returned value must be freed with g_param_spec_unref().";
+        }
+        elsif (exists $argtype->{array}) {
+            $retdesc .= "\n *          The returned value must be freed with g_free().";
+        }
+    }
+    else {
+        # No return values
+        $rettype = 'void';
+    }
 
-               $value = "gimp_value_array_index (args, $argc)";
+    # The parameters to the function
+    my $arglist = "";
+    my $argdesc = "";
+    my $sincedesc = "";
+    my $value_array = "";
+    my $arg_array = "";
+    my $argc = 0;
+    foreach (@inargs) {
+        my ($type, @typeinfo) = &arg_parse($_->{type});
+        my $arg = $arg_types{$type};
+        my $var = $_->{name};
+        my $desc = exists $_->{desc} ? $_->{desc} : "";
+        my $var_len;
+        my $value;
+        my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE'));
+
+        $var .= '_ID' if $is_id;
+
+        # This gets passed to gimp_value_array_new_with_types()
+        if ($type eq 'enum') {
+            $enum_type = $typeinfo[0];
+            $enum_type =~ s/([a-z])([A-Z])/$1_$2/g;
+            $enum_type =~ s/([A-Z]+)([A-Z])/$1_$2/g;
+            $enum_type =~ tr/[a-z]/[A-Z]/;
+            $enum_type =~ s/^GIMP/GIMP_TYPE/;
+            $enum_type =~ s/^GEGL/GEGL_TYPE/;
+
+            $value_array .= "$enum_type, ";
+        }
+        else {
+            $value_array .= "$arg->{gtype}, ";
+        }
 
-               if (exists $arrayarg->{name}) {
-                   $var_len = $arrayarg->{name};
-               }
-               else {
-                   $var_len = 'num_' . $_->{name};
-               }
+        if (exists $_->{array}) {
+            $value_array .= "NULL";
+        }
+        elsif (exists $arg->{convert_func} && ! $api_deprecated) {
+            $value_array .= eval qq/"$arg->{convert_func}"/;
+        }
+        else {
+            $value_array .= "$var";
+        }
 
-               # This is the list of g_value_set_foo_array
-               $arg_array .= eval qq/"  $arg->{set_value_func};\n"/;
-           }
+        $value_array .= ",\n" . " " x 42;
 
-           $usednames{$_->{name}}++;
+        if (exists $_->{array}) {
+            my $arrayarg = $_->{array};
 
-           $arglist .= &libtype($_, 0);
-           $arglist .= $_->{name};
-           $arglist .= '_ID' if $arg->{id};
-           $arglist .= ', ';
+            $value = "gimp_value_array_index (args, $argc)";
 
-           $argdesc .= " * \@$_->{name}";
-           $argdesc .= '_ID' if $arg->{id};
-           $argdesc .= ":";
+            if (exists $arrayarg->{name}) {
+                $var_len = $arrayarg->{name};
+            }
+            else {
+                $var_len = 'num_' . $_->{name};
+            }
 
-           if (exists $arg->{array}) {
-               $argdesc .= " (array length=@inargs[$argc - 1]->{name})";
-           }
+            # This is the list of g_value_set_foo_array
+            $arg_array .= eval qq/"  $arg->{set_value_func};\n"/;
+        }
 
-           if (exists $arg->{in_annotate}) {
-               $argdesc .= " $arg->{in_annotate}";
-           }
+        $usednames{$_->{name}}++;
 
-           if (exists $arg->{array} || exists $arg->{in_annotate}) {
-               $argdesc .= ":";
-            }
+        $arglist .= &libtype($_, 0, $api_deprecated);
+        $arglist .= $_->{name};
+        $arglist .= '_ID' if $is_id;
+        $arglist .= ', ';
 
-           $argdesc .= " $desc";
+        $argdesc .= " * \@$_->{name}";
+        $argdesc .= '_ID' if $is_id;
+        $argdesc .= ":";
 
-            unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
-            $argdesc .= "\n";
+        if (exists $arg->{array}) {
+            $argdesc .= " (array length=@inargs[$argc - 1]->{name})";
+        }
 
-           $argc++;
-       }
+        if (exists $arg->{in_annotate}) {
+            $argdesc .= " $arg->{in_annotate}";
+        }
 
-       # This marshals the return value(s)
-       my $return_args = "";
-       my $return_marshal = "gimp_value_array_unref (return_vals);";
+        if (exists $arg->{array} || exists $arg->{in_annotate}) {
+            $argdesc .= ":";
+        }
 
-       # return success/failure boolean if we don't have anything else
-       if ($rettype eq 'void') {
-           $return_args .= "\n" . ' ' x 2 . "gboolean success = TRUE;";
-           $retdesc .= " TRUE on success.";
-       }
+        $argdesc .= " $desc";
 
-       # We only need to bother with this if we have to return a value
-       if ($rettype ne 'void' || $retvoid) {
-           my $once = 0;
-           my $firstvar;
-           my @initnums;
+        unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
+        $argdesc .= "\n";
 
-           foreach (@outargs) {
-               my ($type) = &arg_parse($_->{type});
-               my $arg = $arg_types{$type};
-               my $var;
+        $argc++;
+    }
 
-               $return_marshal = "" unless $once++;
+    # This marshals the return value(s)
+    my $return_args = "";
+    my $return_marshal = "gimp_value_array_unref (return_vals);";
 
-               $_->{libname} = exists $usednames{$_->{name}} ? "ret_$_->{name}"
-                                                             : $_->{name};
+    # return success/failure boolean if we don't have anything else
+    if ($rettype eq 'void') {
+        $return_args .= "\n" . ' ' x 2 . "gboolean success = TRUE;";
+        $retdesc .= " TRUE on success.";
+    }
 
-               if (exists $_->{num}) {
-                   if (!exists $_->{no_lib}) {
-                       push @initnums, $_;
-                   }
-               }
-               elsif (exists $_->{retval}) {
-                   $return_args .= "\n" . ' ' x 2;
-                   $return_args .= &libtype($_, 1);
+    # We only need to bother with this if we have to return a value
+    if ($rettype ne 'void' || $retvoid) {
+        my $once = 0;
+        my $firstvar;
+        my @initnums;
 
-                   # The return value variable
-                   $var = $_->{libname};
-                   $var .= '_ID' if $arg->{id};
-                   $return_args .= $var;
+        foreach (@outargs) {
+            my ($type) = &arg_parse($_->{type});
+            my $arg = $arg_types{$type};
+            my $var;
+            my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE'));
 
-                   # Save the first var to "return" it
-                   $firstvar = $var unless defined $firstvar;
+            $return_marshal = "" unless $once++;
 
-                   if ($arg->{id}) {
-                       # Initialize all IDs to -1
-                       $return_args .= " = -1";
-                   }
-                   elsif ($_->{libdef}) {
-                       $return_args .= " = $_->{libdef}";
-                   }
-                   else {
-                       $return_args .= " = $arg->{init_value}";
-                   }
-
-                   $return_args .= ";";
+            $_->{libname} = exists $usednames{$_->{name}} ? "ret_$_->{name}"
+                                                          : $_->{name};
 
-                   if (exists $_->{array} && exists $_->{array}->{no_lib}) {
-                       $return_args .= "\n" . ' ' x 2 . "gint num_$var;";
-                   }
-               }
-               elsif ($retvoid) {
-                   push @initnums, $_ unless exists $arg->{struct};
-               }
-           }
+            if (exists $_->{num}) {
+                if (!exists $_->{no_lib}) {
+                    push @initnums, $_;
+                }
+            }
+            elsif (exists $_->{retval}) {
+                $return_args .= "\n" . ' ' x 2;
+                $return_args .= &libtype($_, 1, $api_deprecated);
+
+                # The return value variable
+                $var = $_->{libname};
+                $var .= '_ID' if $is_id;
+                $return_args .= $var;
+
+                # Save the first var to "return" it
+                $firstvar = $var unless defined $firstvar;
+
+                if ($is_id) {
+                    # Initialize all IDs to -1
+                    $return_args .= " = -1";
+                }
+                elsif ($_->{libdef}) {
+                    $return_args .= " = $_->{libdef}";
+                }
+                else {
+                    $return_args .= " = $arg->{init_value}";
+                }
+
+                $return_args .= ";";
+
+                if (exists $_->{array} && exists $_->{array}->{no_lib}) {
+                    $return_args .= "\n" . ' ' x 2 . "gint num_$var;";
+                }
+            }
+            elsif ($retvoid) {
+                push @initnums, $_ unless exists $arg->{struct};
+            }
+        }
 
-           if (scalar(@initnums)) {
-               foreach (@initnums) {
-                   $return_marshal .= "\*$_->{libname} = ";
-                   my ($type) = &arg_parse($_->{type});
-                   for ($arg_types{$type}->{type}) {
-                       /\*$/     && do { $return_marshal .= "NULL";  last };
-                       /boolean/ && do { $return_marshal .= "FALSE"; last };
-                       /double/  && do { $return_marshal .= "0.0";   last };
-                                         $return_marshal .= "0";
-                   }
-                   $return_marshal .= ";\n  ";
-               }
-               $return_marshal =~ s/\n  $/\n\n  /s;
-           }
+        if (scalar(@initnums)) {
+            foreach (@initnums) {
+                $return_marshal .= "\*$_->{libname} = ";
+                my ($type) = &arg_parse($_->{type});
+                for ($arg_types{$type}->{type}) {
+                    /\*$/     && do { $return_marshal .= "NULL";  last };
+                    /boolean/ && do { $return_marshal .= "FALSE"; last };
+                    /double/  && do { $return_marshal .= "0.0";   last };
+                                      $return_marshal .= "0";
+                }
+                $return_marshal .= ";\n  ";
+            }
+            $return_marshal =~ s/\n  $/\n\n  /s;
+        }
 
-           if ($rettype eq 'void') {
-               $return_marshal .= <<CODE;
+        if ($rettype eq 'void') {
+            $return_marshal .= <<CODE;
 success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   if (success)
 CODE
-           }
-           else {
-               $return_marshal .= <<CODE;
+        }
+        else {
+            $return_marshal .= <<CODE;
 if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
 CODE
-           }
-
-           $return_marshal .= ' ' x 4 . "{\n" if $#outargs;
-
-           my $argc = 1; my ($numpos, $numtype);
-           foreach (@outargs) {
-               my ($type) = &arg_parse($_->{type});
-                my $desc = exists $_->{desc} ? $_->{desc} : "";
-               my $arg = $arg_types{$type};
-               my $var;
-
-               # The return value variable
-               $var = "";
-
-               unless (exists $_->{retval}) {
-                   $var .= '*';
-                   $arglist .= &libtype($_, 1);
-                   $arglist .= '*' unless exists $arg->{struct};
-                   $arglist .= "$_->{libname}";
-                   $arglist .= '_ID' if $arg->{id};
-                   $arglist .= ', ';
-
-                   $argdesc .= " * \@$_->{libname}";
-                   $argdesc .= '_ID' if $arg->{id};
-
-                   if ($arg->{name} eq 'COLOR') {
-                       $argdesc .= ": (out caller-allocates)";
-                   }
-                   else {
-                       $argdesc .= ": (out)";
-                   }
-
-                   if (exists $arg->{array}) {
-                       $argdesc .= " (array length=@outargs[$argc - 2]->{name})";
-                   }
+        }
 
-                   if (exists $arg->{out_annotate}) {
-                       $argdesc .= " $arg->{out_annotate}";
-                   }
+        $return_marshal .= ' ' x 4 . "{\n" if $#outargs;
+
+        my $argc = 1; my ($numpos, $numtype);
+        foreach (@outargs) {
+            my ($type) = &arg_parse($_->{type});
+            my $desc = exists $_->{desc} ? $_->{desc} : "";
+            my $arg = $arg_types{$type};
+            my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE'));
+            my $var;
+
+            # The return value variable
+            $var = "";
+
+            unless (exists $_->{retval}) {
+                $var .= '*';
+                $arglist .= &libtype($_, 1);
+                $arglist .= '*' unless exists $arg->{struct};
+                $arglist .= "$_->{libname}";
+                $arglist .= '_ID' if $is_id;
+                $arglist .= ', ';
+
+                $argdesc .= " * \@$_->{libname}";
+                $argdesc .= '_ID' if $is_id;
+
+                if ($arg->{name} eq 'COLOR') {
+                    $argdesc .= ": (out caller-allocates)";
+                }
+                else {
+                    $argdesc .= ": (out)";
+                }
+
+                if (exists $arg->{array}) {
+                    $argdesc .= " (array length=@outargs[$argc - 2]->{name})";
+                }
+
+                if ($api_deprecated) {
+                    if (exists $arg->{out_annotate_d}) {
+                        $argdesc .= " $arg->{out_annotate_d}";
+                    }
+                }
+                elsif (exists $arg->{out_annotate}) {
+                    $argdesc .= " $arg->{out_annotate}";
+                }
 
-                   $argdesc .= ": $desc";
-               }
+                $argdesc .= ": $desc";
+            }
 
-               $var = exists $_->{retval} ? "" : '*';
-               $var .= $_->{libname};
-               $var .= '_ID' if $arg->{id};
+            $var = exists $_->{retval} ? "" : '*';
+            $var .= $_->{libname};
+            $var .= '_ID' if $is_id;
 
-               $value = "gimp_value_array_index (return_vals, $argc)";
+            $value = "gimp_value_array_index (return_vals, $argc)";
 
-               $return_marshal .= ' ' x 2 if $#outargs;
-               $return_marshal .= eval qq/"    $arg->{dup_value_func};\n"/;
+            $return_marshal .= ' ' x 2 if $#outargs;
+            if ($api_deprecated && $arg->{dup_value_func_d}) {
+                $return_marshal .= eval qq/"    $arg->{dup_value_func_d};\n"/;
+            }
+            else {
+                $return_marshal .= eval qq/"    $arg->{dup_value_func};\n"/;
+            }
 
-                if ($argdesc) {
-                    unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
-                    unless ($argdesc =~ /\n$/)       { $argdesc .= "\n" }
-               }
+            if ($argdesc) {
+                unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
+                unless ($argdesc =~ /\n$/)       { $argdesc .= "\n" }
+            }
 
-               $argc++;
-           }
+            $argc++;
+        }
 
-           $return_marshal .= ' ' x 4 . "}\n" if $#outargs;
+        $return_marshal .= ' ' x 4 . "}\n" if $#outargs;
 
-           $return_marshal .= <<'CODE';
+        $return_marshal .= <<'CODE';
 
   gimp_value_array_unref (return_vals);
 
 CODE
-           unless ($retvoid) {
-               $return_marshal .= ' ' x 2 . "return $firstvar;";
-           }
-           else {
-               $return_marshal .= ' ' x 2 . "return success;";
-           }
-       }
-       else {
-           $return_marshal = <<CODE;
+        unless ($retvoid) {
+            $return_marshal .= ' ' x 2 . "return $firstvar;";
+        }
+        else {
+            $return_marshal .= ' ' x 2 . "return success;";
+        }
+    }
+    else {
+        $return_marshal = <<CODE;
 success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   $return_marshal
@@ -445,94 +473,93 @@ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB
   return success;
 CODE
 
-           chop $return_marshal;
-       }
+        chop $return_marshal;
+    }
 
-       if ($arglist) {
-           my @arglist = split(/, /, $arglist);
-           my $longest = 0; my $seen = 0;
-           foreach (@arglist) {
-               /(const \w+) \S+/ || /(\w+) \S+/;
-               my $len = length($1);
-               my $num = scalar @{[ /\*/g ]};
-               $seen = $num if $seen < $num;
-               $longest = $len if $longest < $len;
-           }
+    if ($arglist) {
+        my @arglist = split(/, /, $arglist);
+        my $longest = 0; my $seen = 0;
+        foreach (@arglist) {
+            /(const \w+) \S+/ || /(\w+) \S+/;
+            my $len = length($1);
+            my $num = scalar @{[ /\*/g ]};
+            $seen = $num if $seen < $num;
+            $longest = $len if $longest < $len;
+        }
 
-           $longest += $seen;
-
-           my $once = 0; $arglist = "";
-           foreach (@arglist) {
-               my $space = rindex($_, ' ');
-               my $len = $longest - $space + 1;
-               $len -= scalar @{[ /\*/g ]};
-               substr($_, $space, 1) = ' ' x $len if $space != -1 && $len > 1;
-               $arglist .= "\t" if $once;
-                $arglist .= $_;
-                $arglist .= ",\n";
-               $once++;
-           }
-           $arglist =~ s/,\n$//;
-       }
-       else {
-           $arglist = "void";
-       }
-       
-       $rettype = 'gboolean' if $rettype eq 'void';
+        $longest += $seen;
+
+        my $once = 0; $arglist = "";
+        foreach (@arglist) {
+            my $space = rindex($_, ' ');
+            my $len = $longest - $space + 1;
+            $len -= scalar @{[ /\*/g ]};
+            substr($_, $space, 1) = ' ' x $len if $space != -1 && $len > 1;
+            $arglist .= "\t" if $once;
+            $arglist .= $_;
+            $arglist .= ",\n";
+            $once++;
+        }
+        $arglist =~ s/,\n$//;
+    }
+    else {
+        $arglist = "void";
+    }
 
-       # Our function prototype for the headers
-       (my $hrettype = $rettype) =~ s/ //g;
+    $rettype = 'gboolean' if $rettype eq 'void';
 
-       my $proto = "$hrettype $wrapped$funcname ($arglist);\n";
-       $proto =~ s/ +/ /g;
+    # Our function prototype for the headers
+    (my $hrettype = $rettype) =~ s/ //g;
 
-        push @{$out->{protos}}, $proto;
+    my $proto = "$hrettype $wrapped$funcname ($arglist);\n";
+    $proto =~ s/ +/ /g;
 
-       my $clist = $arglist;
-       my $padlen = length($wrapped) + length($funcname) + 2;
-       my $padding = ' ' x $padlen;
-       $clist =~ s/\t/$padding/eg;
+    push @{$out->{protos}}, $proto;
 
-        if ($proc->{since}) {
-           $sincedesc = "\n *\n * Since: $proc->{since}";
-       }
+    my $clist = $arglist;
+    my $padlen = length($wrapped) + length($funcname) + 2;
+    my $padding = ' ' x $padlen;
+    $clist =~ s/\t/$padding/eg;
 
-       my $procdesc = '';
+    if ($proc->{since}) {
+        $sincedesc = "\n *\n * Since: $proc->{since}";
+    }
 
-       if ($proc->{deprecated}) {
-            if ($proc->{deprecated} eq 'NONE') {
-               if ($proc->{blurb}) {
-                   $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n";
-               }
-               if ($proc->{help}) {
-                   $procdesc .= &desc_wrap($proc->{help}) . "\n *\n";
-               }
-               $procdesc .= &desc_wrap("Deprecated: There is no replacement " .
-                                       "for this procedure.");
-           }
-           else {
-               my $underscores = $proc->{deprecated};
-               $underscores =~ s/-/_/g;
+    my $procdesc = '';
 
-               if ($proc->{blurb}) {
-                   $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n";
-               }
-               if ($proc->{help}) {
-                   $procdesc .= &desc_wrap($proc->{help}) . "\n *\n";
-               }
-               $procdesc .= &desc_wrap("Deprecated: " .
-                                       "Use $underscores() instead.");
-           }
-       }
-       else {
-           $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n" .
-                       &desc_wrap($proc->{help});
-       }
+    if ($proc->{deprecated}) {
+        if ($proc->{deprecated} eq 'NONE') {
+            if ($proc->{blurb}) {
+                $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n";
+            }
+            if ($proc->{help}) {
+                $procdesc .= &desc_wrap($proc->{help}) . "\n *\n";
+            }
+            $procdesc .= &desc_wrap("Deprecated: There is no replacement " .
+                                    "for this procedure.");
+        }
+        else {
+            my $underscores = $proc->{deprecated};
+            $underscores =~ s/-/_/g;
 
-       $out->{code} .= <<CODE;
+            if ($proc->{blurb}) {
+                $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n";
+            }
+            if ($proc->{help}) {
+                $procdesc .= &desc_wrap($proc->{help}) . "\n *\n";
+            }
+            $procdesc .= &desc_wrap("Deprecated: " .
+                                    "Use $underscores() instead.");
+        }
+    }
+    else {
+        $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n" .
+                    &desc_wrap($proc->{help});
+    }
+    return <<CODE;
 
 /**
- * $wrapped$funcname:
+ * $wrapped$funcname:$func_annotations
 $argdesc *
 $procdesc
  *
@@ -560,6 +587,43 @@ $arg_array
   $return_marshal
 }
 CODE
+}
+
+sub generate {
+    my @procs = @{(shift)};
+    my %out;
+
+    foreach $name (@procs) {
+       my $proc = $main::pdb{$name};
+       my $out = \%{$out{$proc->{group}}};
+
+       my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs});
+       my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs});
+
+        # Check if any of the argument or returned value is an image.
+        $has_image_arg = 0;
+       foreach (@outargs) {
+           my ($type, @typeinfo) = &arg_parse($_->{type});
+           my $arg = $arg_types{$type};
+           if ($arg->{name} eq 'IMAGE') {
+                $has_image_arg = 1;
+                last;
+            }
+       }
+        unless ($has_image_arg) {
+            foreach (@inargs) {
+                my ($type, @typeinfo) = &arg_parse($_->{type});
+                my $arg = $arg_types{$type};
+                if ($arg->{name} eq 'IMAGE') {
+                    $has_image_arg = 1;
+                    last;
+                }
+            }
+        }
+        $out->{code} .= generate_fun($proc, $out, 0);
+        if ($has_image_arg) {
+            $out->{code} .= generate_fun($proc, $out, 1);
+        }
     }
 
     my $lgpl_top = <<'LGPL';
diff --git a/pdb/pdb.pl b/pdb/pdb.pl
index 03fcfeb84c..409ddee7c7 100644
--- a/pdb/pdb.pl
+++ b/pdb/pdb.pl
@@ -166,7 +166,8 @@ package Gimp::CodeGen::pdb;
                     init_value      => 'NULL',
                     out_annotate    => '(transfer full)',
                     get_value_func  => '$var = gimp_value_get_image ($value, gimp)',
-                    dup_value_func  => '$var = gimp_image_new_by_id (g_value_get_int ($value))',
+                    dup_value_func  => '$var = gimp_image_new_by_id (gimp_value_get_image_id ($value))',
+                    dup_value_func_d=> '$var = gimp_value_get_image_id ($value)',
                     set_value_func  => 'gimp_value_set_image_id ($value, gimp_image_get_id ($var))',
                     take_value_func => 'gimp_value_set_image ($value, $var)',
                     convert_func    => 'gimp_image_get_id ($var)',



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]