[gimp/wip/Jehan/classy-GIMP: 10/50] libgimp, pdb: add GimpItem > GimpDrawable > GimpLayer classes.



commit 70b10ea84a641266fdc058360c504c9f77b07b5b
Author: Jehan <jehan girinstud io>
Date:   Tue Aug 13 13:59:33 2019 +0200

    libgimp, pdb: add GimpItem > GimpDrawable > GimpLayer classes.
    
    Only class and subclasses creation and PDB generation for this first
    step.
    I'll later do other types of items.

 libgimp/Makefile.gi             |    2 +
 libgimp/gimp.h                  |    1 +
 libgimp/gimpdrawable.c          |   18 +
 libgimp/gimpdrawable.h          |   34 +
 libgimp/gimpdrawable_pdb.c      | 1760 ++++++++++++++++++++++++++-----
 libgimp/gimpdrawable_pdb.h      |  154 ++-
 libgimp/gimpdrawablecolor_pdb.c |  946 +++++++++++++++--
 libgimp/gimpdrawablecolor_pdb.h |  110 +-
 libgimp/gimpdrawableedit_pdb.c  |  381 ++++++-
 libgimp/gimpdrawableedit_pdb.h  |   72 +-
 libgimp/gimpedit_pdb.c          |  318 +++++-
 libgimp/gimpedit_pdb.h          |   48 +-
 libgimp/gimpfileops_pdb.c       |   24 +-
 libgimp/gimpfileops_pdb.h       |   34 +-
 libgimp/gimpfloatingsel_pdb.c   |  178 +++-
 libgimp/gimpfloatingsel_pdb.h   |   22 +-
 libgimp/gimpimage_pdb.c         |  193 ++--
 libgimp/gimpimage_pdb.h         |   46 +-
 libgimp/gimpimageselect_pdb.c   |   18 +-
 libgimp/gimpimageselect_pdb.h   |    6 +-
 libgimp/gimpitem.c              |  165 +++
 libgimp/gimpitem.h              |   75 ++
 libgimp/gimpitem_pdb.c          | 2049 ++++++++++++++++++++++++++++++------
 libgimp/gimpitem_pdb.h          |  152 ++-
 libgimp/gimpitemtransform_pdb.c |  896 ++++++++++++++--
 libgimp/gimpitemtransform_pdb.h |  184 ++--
 libgimp/gimplayer.c             |   19 +
 libgimp/gimplayer.h             |   33 +
 libgimp/gimplayer_pdb.c         | 2179 +++++++++++++++++++++++++++++++--------
 libgimp/gimplayer_pdb.h         |  243 +++--
 libgimp/gimppainttools_pdb.c    | 1362 ++++++++++++++++++++----
 libgimp/gimppainttools_pdb.h    |  134 ++-
 libgimp/gimpselection_pdb.c     |   56 +-
 libgimp/gimpselection_pdb.h     |   65 +-
 libgimp/gimptextlayer_pdb.c     | 1899 ++++++++++++++++++++++++++++------
 libgimp/gimptextlayer_pdb.h     |  157 ++-
 libgimp/gimptexttool_pdb.c      |   16 +-
 libgimp/gimptexttool_pdb.h      |   20 +-
 libgimp/gimptypes.h             |    3 +
 libgimp/gimpvectors_pdb.c       |    6 +-
 libgimp/gimpvectors_pdb.h       |    2 +-
 pdb/lib.pl                      |   39 +-
 pdb/pdb.pl                      |   18 +-
 43 files changed, 11763 insertions(+), 2374 deletions(-)
---
diff --git a/libgimp/Makefile.gi b/libgimp/Makefile.gi
index fc982dcfd9..5b2147c69d 100644
--- a/libgimp/Makefile.gi
+++ b/libgimp/Makefile.gi
@@ -119,6 +119,7 @@ libgimp_introspectable_headers = \
        ../libgimp/gimpimage.h                  \
        ../libgimp/gimpimagecolorprofile.h      \
        ../libgimp/gimpimageprocedure.h         \
+       ../libgimp/gimpitem.h                   \
        ../libgimp/gimplayer.h                  \
        ../libgimp/gimploadprocedure.h          \
        ../libgimp/gimppaletteselect.h          \
@@ -147,6 +148,7 @@ libgimp_introspectable = \
        ../libgimp/gimpimage.c                  \
        ../libgimp/gimpimagecolorprofile.c      \
        ../libgimp/gimpimageprocedure.c         \
+       ../libgimp/gimpitem.c                   \
        ../libgimp/gimplayer.c                  \
        ../libgimp/gimploadprocedure.c          \
        ../libgimp/gimppaletteselect.c          \
diff --git a/libgimp/gimp.h b/libgimp/gimp.h
index 46e14f8473..8d3bc6171d 100644
--- a/libgimp/gimp.h
+++ b/libgimp/gimp.h
@@ -44,6 +44,7 @@
 #include <libgimp/gimpimage.h>
 #include <libgimp/gimpimagecolorprofile.h>
 #include <libgimp/gimpimageprocedure.h>
+#include <libgimp/gimpitem.h>
 #include <libgimp/gimplayer.h>
 #include <libgimp/gimploadprocedure.h>
 #include <libgimp/gimplegacy.h>
diff --git a/libgimp/gimpdrawable.c b/libgimp/gimpdrawable.c
index da9b5c332a..c0a9eff740 100644
--- a/libgimp/gimpdrawable.c
+++ b/libgimp/gimpdrawable.c
@@ -26,6 +26,24 @@
 #include "gimptilebackendplugin.h"
 
 
+G_DEFINE_ABSTRACT_TYPE (GimpDrawable, gimp_drawable, GIMP_TYPE_ITEM)
+
+#define parent_class gimp_drawable_parent_class
+
+static void
+gimp_drawable_class_init (GimpDrawableClass *klass)
+{
+}
+
+static void
+gimp_drawable_init (GimpDrawable *drawable)
+{
+}
+
+
+/* Public API. */
+
+
 guchar *
 gimp_drawable_get_thumbnail_data (gint32  drawable_ID,
                                   gint   *width,
diff --git a/libgimp/gimpdrawable.h b/libgimp/gimpdrawable.h
index 04b05610d8..95c4abc57a 100644
--- a/libgimp/gimpdrawable.h
+++ b/libgimp/gimpdrawable.h
@@ -29,6 +29,40 @@ G_BEGIN_DECLS
 
 /* For information look into the C source or the html documentation */
 
+#include <libgimp/gimpitem.h>
+
+#define GIMP_TYPE_DRAWABLE            (gimp_drawable_get_type ())
+#define GIMP_DRAWABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DRAWABLE, GimpDrawable))
+#define GIMP_DRAWABLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE, 
GimpDrawableClass))
+#define GIMP_IS_DRAWABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DRAWABLE))
+#define GIMP_IS_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE))
+#define GIMP_DRAWABLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DRAWABLE, 
GimpDrawableClass))
+
+
+typedef struct _GimpDrawableClass   GimpDrawableClass;
+
+struct _GimpDrawable
+{
+  GimpItem      parent_instance;
+};
+
+struct _GimpDrawableClass
+{
+  GimpItemClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gimp_reserved1) (void);
+  void (*_gimp_reserved2) (void);
+  void (*_gimp_reserved3) (void);
+  void (*_gimp_reserved4) (void);
+  void (*_gimp_reserved5) (void);
+  void (*_gimp_reserved6) (void);
+  void (*_gimp_reserved7) (void);
+  void (*_gimp_reserved8) (void);
+  void (*_gimp_reserved9) (void);
+};
+
+GType        gimp_drawable_get_type               (void) G_GNUC_CONST;
 
 GeglBuffer * gimp_drawable_get_buffer             (gint32         drawable_ID);
 GeglBuffer * gimp_drawable_get_shadow_buffer      (gint32         drawable_ID);
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index 98c1dfc01d..8078e7cbc6 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -36,7 +36,7 @@
 
 /**
  * _gimp_drawable_get_format:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  *
  * Returns the drawable's Babl format
  *
@@ -51,7 +51,7 @@
  * Since: 2.10
  **/
 gchar *
-_gimp_drawable_get_format (gint32 drawable_ID)
+_gimp_drawable_get_format (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -59,7 +59,7 @@ _gimp_drawable_get_format (gint32 drawable_ID)
   gchar *format = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -80,22 +80,23 @@ _gimp_drawable_get_format (gint32 drawable_ID)
 }
 
 /**
- * _gimp_drawable_get_thumbnail_format:
+ * __gimp_drawable_get_format: (skip)
  * @drawable_ID: The drawable.
  *
- * Returns the drawable's thumbnail Babl format
+ * Returns the drawable's Babl format
  *
- * This procedure returns the drawable's thumbnail Babl format.
- * Thumbnails are always 8-bit images, see gimp_drawable_thumbnail()
- * and gimp_drawable_sub_thmbnail().
+ * This procedure returns the drawable's Babl format.
+ * Note that the actual PDB procedure only transfers the format's
+ * encoding. In order to get to the real format, the libbgimp C wrapper
+ * must be used.
  *
- * Returns: (transfer full): The drawable's thumbnail Babl format.
+ * Returns: The drawable's Babl format.
  *          The returned value must be freed with g_free().
  *
- * Since: 2.10.14
+ * Since: 2.10
  **/
 gchar *
-_gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
+__gimp_drawable_get_format (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -108,10 +109,10 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-get-thumbnail-format",
+                                                "gimp-drawable-get-format",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-get-thumbnail-format",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-get-format",
                                             args);
   gimp_value_array_unref (args);
 
@@ -124,64 +125,71 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
 }
 
 /**
- * gimp_drawable_type:
- * @drawable_ID: The drawable.
+ * _gimp_drawable_get_thumbnail_format:
+ * @drawable: The drawable.
  *
- * Returns the drawable's type.
+ * Returns the drawable's thumbnail Babl format
  *
- * This procedure returns the drawable's type.
+ * This procedure returns the drawable's thumbnail Babl format.
+ * Thumbnails are always 8-bit images, see gimp_drawable_thumbnail()
+ * and gimp_drawable_sub_thmbnail().
  *
- * Returns: The drawable's type.
+ * Returns: (transfer full): The drawable's thumbnail Babl format.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.10.14
  **/
-GimpImageType
-gimp_drawable_type (gint32 drawable_ID)
+gchar *
+_gimp_drawable_get_thumbnail_format (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpImageType type = 0;
+  gchar *format = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-type",
+                                                "gimp-drawable-get-thumbnail-format",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-type",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-get-thumbnail-format",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+    format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return type;
+  return format;
 }
 
 /**
- * gimp_drawable_type_with_alpha:
+ * __gimp_drawable_get_thumbnail_format: (skip)
  * @drawable_ID: The drawable.
  *
- * Returns the drawable's type with alpha.
+ * Returns the drawable's thumbnail Babl format
  *
- * This procedure returns the drawable's type as if had an alpha
- * channel. If the type is currently Gray, for instance, the returned
- * type would be GrayA. If the drawable already has an alpha channel,
- * the drawable's type is simply returned.
+ * This procedure returns the drawable's thumbnail Babl format.
+ * Thumbnails are always 8-bit images, see gimp_drawable_thumbnail()
+ * and gimp_drawable_sub_thmbnail().
  *
- * Returns: The drawable's type with alpha.
+ * Returns: The drawable's thumbnail Babl format.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.10.14
  **/
-GimpImageType
-gimp_drawable_type_with_alpha (gint32 drawable_ID)
+gchar *
+__gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpImageType type_with_alpha = 0;
+  gchar *format = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
@@ -189,80 +197,77 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-type-with-alpha",
+                                                "gimp-drawable-get-thumbnail-format",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-type-with-alpha",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-get-thumbnail-format",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    type_with_alpha = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+    format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return type_with_alpha;
+  return format;
 }
 
 /**
- * gimp_drawable_has_alpha:
- * @drawable_ID: The drawable.
+ * gimp_drawable_type:
+ * @drawable: The drawable.
  *
- * Returns TRUE if the drawable has an alpha channel.
+ * Returns the drawable's type.
  *
- * This procedure returns whether the specified drawable has an alpha
- * channel. This can only be true for layers, and the associated type
- * will be one of: { RGBA , GRAYA, INDEXEDA }.
+ * This procedure returns the drawable's type.
  *
- * Returns: Does the drawable have an alpha channel?
+ * Returns: The drawable's type.
  **/
-gboolean
-gimp_drawable_has_alpha (gint32 drawable_ID)
+GimpImageType
+gimp_drawable_type (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean has_alpha = FALSE;
+  GimpImageType type = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-has-alpha",
+                                                "gimp-drawable-type",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-has-alpha",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-type",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    has_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return has_alpha;
+  return type;
 }
 
 /**
- * gimp_drawable_is_rgb:
+ * _gimp_drawable_type: (skip)
  * @drawable_ID: The drawable.
  *
- * Returns whether the drawable is an RGB type.
+ * Returns the drawable's type.
  *
- * This procedure returns TRUE if the specified drawable is of type {
- * RGB, RGBA }.
+ * This procedure returns the drawable's type.
  *
- * Returns: TRUE if the drawable is an RGB type.
+ * Returns: The drawable's type.
  **/
-gboolean
-gimp_drawable_is_rgb (gint32 drawable_ID)
+GimpImageType
+_gimp_drawable_type (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean is_rgb = FALSE;
+  GimpImageType type = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
@@ -270,79 +275,83 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-is-rgb",
+                                                "gimp-drawable-type",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-is-rgb",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-type",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    is_rgb = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return is_rgb;
+  return type;
 }
 
 /**
- * gimp_drawable_is_gray:
- * @drawable_ID: The drawable.
+ * gimp_drawable_type_with_alpha:
+ * @drawable: The drawable.
  *
- * Returns whether the drawable is a grayscale type.
+ * Returns the drawable's type with alpha.
  *
- * This procedure returns TRUE if the specified drawable is of type {
- * Gray, GrayA }.
+ * This procedure returns the drawable's type as if had an alpha
+ * channel. If the type is currently Gray, for instance, the returned
+ * type would be GrayA. If the drawable already has an alpha channel,
+ * the drawable's type is simply returned.
  *
- * Returns: TRUE if the drawable is a grayscale type.
+ * Returns: The drawable's type with alpha.
  **/
-gboolean
-gimp_drawable_is_gray (gint32 drawable_ID)
+GimpImageType
+gimp_drawable_type_with_alpha (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean is_gray = FALSE;
+  GimpImageType type_with_alpha = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-is-gray",
+                                                "gimp-drawable-type-with-alpha",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-is-gray",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-type-with-alpha",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    is_gray = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    type_with_alpha = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return is_gray;
+  return type_with_alpha;
 }
 
 /**
- * gimp_drawable_is_indexed:
+ * _gimp_drawable_type_with_alpha: (skip)
  * @drawable_ID: The drawable.
  *
- * Returns whether the drawable is an indexed type.
+ * Returns the drawable's type with alpha.
  *
- * This procedure returns TRUE if the specified drawable is of type {
- * Indexed, IndexedA }.
+ * This procedure returns the drawable's type as if had an alpha
+ * channel. If the type is currently Gray, for instance, the returned
+ * type would be GrayA. If the drawable already has an alpha channel,
+ * the drawable's type is simply returned.
  *
- * Returns: TRUE if the drawable is an indexed type.
+ * Returns: The drawable's type with alpha.
  **/
-gboolean
-gimp_drawable_is_indexed (gint32 drawable_ID)
+GimpImageType
+_gimp_drawable_type_with_alpha (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean is_indexed = FALSE;
+  GimpImageType type_with_alpha = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
@@ -350,77 +359,81 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-is-indexed",
+                                                "gimp-drawable-type-with-alpha",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-is-indexed",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-type-with-alpha",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    is_indexed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    type_with_alpha = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return is_indexed;
+  return type_with_alpha;
 }
 
 /**
- * gimp_drawable_bpp:
- * @drawable_ID: The drawable.
+ * gimp_drawable_has_alpha:
+ * @drawable: The drawable.
  *
- * Returns the bytes per pixel.
+ * Returns TRUE if the drawable has an alpha channel.
  *
- * This procedure returns the number of bytes per pixel.
+ * This procedure returns whether the specified drawable has an alpha
+ * channel. This can only be true for layers, and the associated type
+ * will be one of: { RGBA , GRAYA, INDEXEDA }.
  *
- * Returns: Bytes per pixel.
+ * Returns: Does the drawable have an alpha channel?
  **/
-gint
-gimp_drawable_bpp (gint32 drawable_ID)
+gboolean
+gimp_drawable_has_alpha (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint bpp = 0;
+  gboolean has_alpha = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-bpp",
+                                                "gimp-drawable-has-alpha",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-bpp",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-has-alpha",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    bpp = g_value_get_int (gimp_value_array_index (return_vals, 1));
+    has_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return bpp;
+  return has_alpha;
 }
 
 /**
- * gimp_drawable_width:
+ * _gimp_drawable_has_alpha: (skip)
  * @drawable_ID: The drawable.
  *
- * Returns the width of the drawable.
+ * Returns TRUE if the drawable has an alpha channel.
  *
- * This procedure returns the specified drawable's width in pixels.
+ * This procedure returns whether the specified drawable has an alpha
+ * channel. This can only be true for layers, and the associated type
+ * will be one of: { RGBA , GRAYA, INDEXEDA }.
  *
- * Returns: Width of drawable.
+ * Returns: Does the drawable have an alpha channel?
  **/
-gint
-gimp_drawable_width (gint32 drawable_ID)
+gboolean
+_gimp_drawable_has_alpha (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint width = 0;
+  gboolean has_alpha = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
@@ -428,83 +441,79 @@ gimp_drawable_width (gint32 drawable_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-width",
+                                                "gimp-drawable-has-alpha",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-width",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-has-alpha",
                                             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));
+    has_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return width;
+  return has_alpha;
 }
 
 /**
- * gimp_drawable_height:
- * @drawable_ID: The drawable.
+ * gimp_drawable_is_rgb:
+ * @drawable: The drawable.
  *
- * Returns the height of the drawable.
+ * Returns whether the drawable is an RGB type.
  *
- * This procedure returns the specified drawable's height in pixels.
+ * This procedure returns TRUE if the specified drawable is of type {
+ * RGB, RGBA }.
  *
- * Returns: Height of drawable.
+ * Returns: TRUE if the drawable is an RGB type.
  **/
-gint
-gimp_drawable_height (gint32 drawable_ID)
+gboolean
+gimp_drawable_is_rgb (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint height = 0;
+  gboolean is_rgb = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-height",
+                                                "gimp-drawable-is-rgb",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-height",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-rgb",
                                             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));
+    is_rgb = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return height;
+  return is_rgb;
 }
 
 /**
- * gimp_drawable_offsets:
+ * _gimp_drawable_is_rgb: (skip)
  * @drawable_ID: The drawable.
- * @offset_x: (out): x offset of drawable.
- * @offset_y: (out): y offset of drawable.
  *
- * Returns the offsets for the drawable.
+ * Returns whether the drawable is an RGB type.
  *
- * This procedure returns the specified drawable's offsets. This only
- * makes sense if the drawable is a layer since channels are anchored.
- * The offsets of a channel will be returned as 0.
+ * This procedure returns TRUE if the specified drawable is of type {
+ * RGB, RGBA }.
  *
- * Returns: TRUE on success.
+ * Returns: TRUE if the drawable is an RGB type.
  **/
 gboolean
-gimp_drawable_offsets (gint32  drawable_ID,
-                       gint   *offset_x,
-                       gint   *offset_y)
+_gimp_drawable_is_rgb (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gboolean is_rgb = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
@@ -512,17 +521,509 @@ gimp_drawable_offsets (gint32  drawable_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-offsets",
+                                                "gimp-drawable-is-rgb",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-offsets",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-rgb",
                                             args);
   gimp_value_array_unref (args);
 
-  *offset_x = 0;
-  *offset_y = 0;
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_rgb = 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 is_rgb;
+}
+
+/**
+ * gimp_drawable_is_gray:
+ * @drawable: The drawable.
+ *
+ * Returns whether the drawable is a grayscale type.
+ *
+ * This procedure returns TRUE if the specified drawable is of type {
+ * Gray, GrayA }.
+ *
+ * Returns: TRUE if the drawable is a grayscale type.
+ **/
+gboolean
+gimp_drawable_is_gray (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_gray = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-is-gray",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-gray",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_gray = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_gray;
+}
+
+/**
+ * _gimp_drawable_is_gray: (skip)
+ * @drawable_ID: The drawable.
+ *
+ * Returns whether the drawable is a grayscale type.
+ *
+ * This procedure returns TRUE if the specified drawable is of type {
+ * Gray, GrayA }.
+ *
+ * Returns: TRUE if the drawable is a grayscale type.
+ **/
+gboolean
+_gimp_drawable_is_gray (gint32 drawable_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_gray = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-is-gray",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-gray",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_gray = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_gray;
+}
+
+/**
+ * gimp_drawable_is_indexed:
+ * @drawable: The drawable.
+ *
+ * Returns whether the drawable is an indexed type.
+ *
+ * This procedure returns TRUE if the specified drawable is of type {
+ * Indexed, IndexedA }.
+ *
+ * Returns: TRUE if the drawable is an indexed type.
+ **/
+gboolean
+gimp_drawable_is_indexed (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_indexed = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-is-indexed",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-indexed",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_indexed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_indexed;
+}
+
+/**
+ * _gimp_drawable_is_indexed: (skip)
+ * @drawable_ID: The drawable.
+ *
+ * Returns whether the drawable is an indexed type.
+ *
+ * This procedure returns TRUE if the specified drawable is of type {
+ * Indexed, IndexedA }.
+ *
+ * Returns: TRUE if the drawable is an indexed type.
+ **/
+gboolean
+_gimp_drawable_is_indexed (gint32 drawable_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_indexed = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-is-indexed",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-is-indexed",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_indexed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_indexed;
+}
+
+/**
+ * gimp_drawable_bpp:
+ * @drawable: The drawable.
+ *
+ * Returns the bytes per pixel.
+ *
+ * This procedure returns the number of bytes per pixel.
+ *
+ * Returns: Bytes per pixel.
+ **/
+gint
+gimp_drawable_bpp (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint bpp = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-bpp",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-bpp",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    bpp = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return bpp;
+}
+
+/**
+ * _gimp_drawable_bpp: (skip)
+ * @drawable_ID: The drawable.
+ *
+ * Returns the bytes per pixel.
+ *
+ * This procedure returns the number of bytes per pixel.
+ *
+ * Returns: Bytes per pixel.
+ **/
+gint
+_gimp_drawable_bpp (gint32 drawable_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint bpp = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-bpp",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-bpp",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    bpp = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return bpp;
+}
+
+/**
+ * gimp_drawable_width:
+ * @drawable: The drawable.
+ *
+ * Returns the width of the drawable.
+ *
+ * This procedure returns the specified drawable's width in pixels.
+ *
+ * Returns: Width of drawable.
+ **/
+gint
+gimp_drawable_width (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint width = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-width",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_width: (skip)
+ * @drawable_ID: The drawable.
+ *
+ * Returns the width of the drawable.
+ *
+ * This procedure returns the specified drawable's width in pixels.
+ *
+ * Returns: Width of drawable.
+ **/
+gint
+_gimp_drawable_width (gint32 drawable_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint width = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-width",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_height:
+ * @drawable: The drawable.
+ *
+ * Returns the height of the drawable.
+ *
+ * This procedure returns the specified drawable's height in pixels.
+ *
+ * Returns: Height of drawable.
+ **/
+gint
+gimp_drawable_height (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint height = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-height",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_height: (skip)
+ * @drawable_ID: The drawable.
+ *
+ * Returns the height of the drawable.
+ *
+ * This procedure returns the specified drawable's height in pixels.
+ *
+ * Returns: Height of drawable.
+ **/
+gint
+_gimp_drawable_height (gint32 drawable_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint height = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-height",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_offsets:
+ * @drawable: The drawable.
+ * @offset_x: (out): x offset of drawable.
+ * @offset_y: (out): y offset of drawable.
+ *
+ * Returns the offsets for the drawable.
+ *
+ * This procedure returns the specified drawable's offsets. This only
+ * makes sense if the drawable is a layer since channels are anchored.
+ * The offsets of a channel will be returned as 0.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_offsets (GimpDrawable *drawable,
+                       gint         *offset_x,
+                       gint         *offset_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-offsets",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-offsets",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *offset_x = 0;
+  *offset_y = 0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *offset_x = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *offset_y = g_value_get_int (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_drawable_offsets: (skip)
+ * @drawable_ID: The drawable.
+ * @offset_x: (out): x offset of drawable.
+ * @offset_y: (out): y offset of drawable.
+ *
+ * Returns the offsets for the drawable.
+ *
+ * This procedure returns the specified drawable's offsets. This only
+ * makes sense if the drawable is a layer since channels are anchored.
+ * The offsets of a channel will be returned as 0.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_drawable_offsets (gint32  drawable_ID,
+                        gint   *offset_x,
+                        gint   *offset_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-offsets",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-offsets",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *offset_x = 0;
+  *offset_y = 0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   if (success)
     {
@@ -537,6 +1038,71 @@ gimp_drawable_offsets (gint32  drawable_ID,
 
 /**
  * gimp_drawable_mask_bounds:
+ * @drawable: The drawable.
+ * @x1: (out): x coordinate of the upper left corner of selection bounds.
+ * @y1: (out): y coordinate of the upper left corner of selection bounds.
+ * @x2: (out): x coordinate of the lower right corner of selection bounds.
+ * @y2: (out): y coordinate of the lower right corner of selection bounds.
+ *
+ * Find the bounding box of the current selection in relation to the
+ * specified drawable.
+ *
+ * This procedure returns whether there is a selection. If there is
+ * one, the upper left and lower right-hand corners of its bounding box
+ * are returned. These coordinates are specified relative to the
+ * drawable's origin, and bounded by the drawable's extents. Please
+ * note that the pixel specified by the lower right-hand 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).
+ * Note that the returned boolean does NOT correspond with the returned
+ * region being empty or not, it always returns whether the selection
+ * is non_empty. See gimp_drawable_mask_intersect() for a boolean
+ * return value which is more useful in most cases.
+ *
+ * Returns: TRUE if there is a selection.
+ **/
+gboolean
+gimp_drawable_mask_bounds (GimpDrawable *drawable,
+                           gint         *x1,
+                           gint         *y1,
+                           gint         *x2,
+                           gint         *y2)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-mask-bounds",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-bounds",
+                                            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));
+      *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 non_empty;
+}
+
+/**
+ * _gimp_drawable_mask_bounds: (skip)
  * @drawable_ID: The drawable.
  * @x1: (out): x coordinate of the upper left corner of selection bounds.
  * @y1: (out): y coordinate of the upper left corner of selection bounds.
@@ -559,124 +1125,315 @@ gimp_drawable_offsets (gint32  drawable_ID,
  * is non_empty. See gimp_drawable_mask_intersect() for a boolean
  * return value which is more useful in most cases.
  *
- * Returns: TRUE if there is a selection.
+ * Returns: TRUE if there is a selection.
+ **/
+gboolean
+_gimp_drawable_mask_bounds (gint32  drawable_ID,
+                            gint   *x1,
+                            gint   *y1,
+                            gint   *x2,
+                            gint   *y2)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-mask-bounds",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-bounds",
+                                            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));
+      *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 non_empty;
+}
+
+/**
+ * gimp_drawable_mask_intersect:
+ * @drawable: The drawable.
+ * @x: (out): x coordinate of the upper left corner of the intersection.
+ * @y: (out): y coordinate of the upper left corner of the intersection.
+ * @width: (out): width of the intersection.
+ * @height: (out): height of the intersection.
+ *
+ * Find the bounding box of the current selection in relation to the
+ * specified drawable.
+ *
+ * This procedure returns whether there is an intersection between the
+ * drawable and the selection. Unlike gimp_drawable_mask_bounds(), the
+ * intersection's bounds are returned as x, y, width, height.
+ * If there is no selection this function returns TRUE and the returned
+ * bounds are the extents of the whole drawable.
+ *
+ * Returns: TRUE if the returned area is not empty.
+ *
+ * Since: 2.2
+ **/
+gboolean
+gimp_drawable_mask_intersect (GimpDrawable *drawable,
+                              gint         *x,
+                              gint         *y,
+                              gint         *width,
+                              gint         *height)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-mask-intersect",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-intersect",
+                                            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));
+      *x = g_value_get_int (gimp_value_array_index (return_vals, 2));
+      *y = g_value_get_int (gimp_value_array_index (return_vals, 3));
+      *width = g_value_get_int (gimp_value_array_index (return_vals, 4));
+      *height = g_value_get_int (gimp_value_array_index (return_vals, 5));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return non_empty;
+}
+
+/**
+ * _gimp_drawable_mask_intersect: (skip)
+ * @drawable_ID: The drawable.
+ * @x: (out): x coordinate of the upper left corner of the intersection.
+ * @y: (out): y coordinate of the upper left corner of the intersection.
+ * @width: (out): width of the intersection.
+ * @height: (out): height of the intersection.
+ *
+ * Find the bounding box of the current selection in relation to the
+ * specified drawable.
+ *
+ * This procedure returns whether there is an intersection between the
+ * drawable and the selection. Unlike gimp_drawable_mask_bounds(), the
+ * intersection's bounds are returned as x, y, width, height.
+ * If there is no selection this function returns TRUE and the returned
+ * bounds are the extents of the whole drawable.
+ *
+ * Returns: TRUE if the returned area is not empty.
+ *
+ * Since: 2.2
+ **/
+gboolean
+_gimp_drawable_mask_intersect (gint32  drawable_ID,
+                               gint   *x,
+                               gint   *y,
+                               gint   *width,
+                               gint   *height)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-mask-intersect",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-intersect",
+                                            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));
+      *x = g_value_get_int (gimp_value_array_index (return_vals, 2));
+      *y = g_value_get_int (gimp_value_array_index (return_vals, 3));
+      *width = g_value_get_int (gimp_value_array_index (return_vals, 4));
+      *height = g_value_get_int (gimp_value_array_index (return_vals, 5));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return non_empty;
+}
+
+/**
+ * gimp_drawable_merge_shadow:
+ * @drawable: The drawable.
+ * @undo: Push merge to undo stack?
+ *
+ * Merge the shadow buffer with the specified drawable.
+ *
+ * This procedure combines the contents of the drawable's shadow buffer
+ * (for temporary processing) with the specified drawable. The 'undo'
+ * parameter specifies whether to add an undo step for the operation.
+ * Requesting no undo is useful for such applications as 'auto-apply'.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_merge_shadow (GimpDrawable *drawable,
+                            gboolean      undo)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_BOOLEAN, undo,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-merge-shadow",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-merge-shadow",
+                                            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_drawable_merge_shadow: (skip)
+ * @drawable_ID: The drawable.
+ * @undo: Push merge to undo stack?
+ *
+ * Merge the shadow buffer with the specified drawable.
+ *
+ * This procedure combines the contents of the drawable's shadow buffer
+ * (for temporary processing) with the specified drawable. The 'undo'
+ * parameter specifies whether to add an undo step for the operation.
+ * Requesting no undo is useful for such applications as 'auto-apply'.
+ *
+ * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_mask_bounds (gint32  drawable_ID,
-                           gint   *x1,
-                           gint   *y1,
-                           gint   *x2,
-                           gint   *y2)
+_gimp_drawable_merge_shadow (gint32   drawable_ID,
+                             gboolean undo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean non_empty = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, undo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-mask-bounds",
+                                                "gimp-drawable-merge-shadow",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-bounds",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-merge-shadow",
                                             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));
-      *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));
-    }
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return non_empty;
+  return success;
 }
 
 /**
- * gimp_drawable_mask_intersect:
- * @drawable_ID: The drawable.
- * @x: (out): x coordinate of the upper left corner of the intersection.
- * @y: (out): y coordinate of the upper left corner of the intersection.
- * @width: (out): width of the intersection.
- * @height: (out): height of the intersection.
+ * gimp_drawable_free_shadow:
+ * @drawable: The drawable.
  *
- * Find the bounding box of the current selection in relation to the
- * specified drawable.
+ * Free the specified drawable's shadow data (if it exists).
  *
- * This procedure returns whether there is an intersection between the
- * drawable and the selection. Unlike gimp_drawable_mask_bounds(), the
- * intersection's bounds are returned as x, y, width, height.
- * If there is no selection this function returns TRUE and the returned
- * bounds are the extents of the whole drawable.
+ * This procedure is intended as a memory saving device. If any shadow
+ * memory has been allocated, it will be freed automatically when the
+ * drawable is removed from the image, or when the plug-in procedure
+ * which allocated it returns.
  *
- * Returns: TRUE if the returned area is not empty.
+ * Returns: TRUE on success.
  *
- * Since: 2.2
+ * Since: 2.6
  **/
 gboolean
-gimp_drawable_mask_intersect (gint32  drawable_ID,
-                              gint   *x,
-                              gint   *y,
-                              gint   *width,
-                              gint   *height)
+gimp_drawable_free_shadow (GimpDrawable *drawable)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean non_empty = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-mask-intersect",
+                                                "gimp-drawable-free-shadow",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-mask-intersect",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-free-shadow",
                                             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));
-      *x = g_value_get_int (gimp_value_array_index (return_vals, 2));
-      *y = g_value_get_int (gimp_value_array_index (return_vals, 3));
-      *width = g_value_get_int (gimp_value_array_index (return_vals, 4));
-      *height = g_value_get_int (gimp_value_array_index (return_vals, 5));
-    }
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return non_empty;
+  return success;
 }
 
 /**
- * gimp_drawable_merge_shadow:
+ * _gimp_drawable_free_shadow: (skip)
  * @drawable_ID: The drawable.
- * @undo: Push merge to undo stack?
  *
- * Merge the shadow buffer with the specified drawable.
+ * Free the specified drawable's shadow data (if it exists).
  *
- * This procedure combines the contents of the drawable's shadow buffer
- * (for temporary processing) with the specified drawable. The 'undo'
- * parameter specifies whether to add an undo step for the operation.
- * Requesting no undo is useful for such applications as 'auto-apply'.
+ * This procedure is intended as a memory saving device. If any shadow
+ * memory has been allocated, it will be freed automatically when the
+ * drawable is removed from the image, or when the plug-in procedure
+ * which allocated it returns.
  *
  * Returns: TRUE on success.
+ *
+ * Since: 2.6
  **/
 gboolean
-gimp_drawable_merge_shadow (gint32   drawable_ID,
-                            gboolean undo)
+_gimp_drawable_free_shadow (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -685,15 +1442,14 @@ gimp_drawable_merge_shadow (gint32   drawable_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_BOOLEAN, undo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-merge-shadow",
+                                                "gimp-drawable-free-shadow",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-merge-shadow",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-free-shadow",
                                             args);
   gimp_value_array_unref (args);
 
@@ -705,22 +1461,28 @@ gimp_drawable_merge_shadow (gint32   drawable_ID,
 }
 
 /**
- * gimp_drawable_free_shadow:
- * @drawable_ID: The drawable.
+ * gimp_drawable_update:
+ * @drawable: The drawable.
+ * @x: x coordinate of upper left corner of update region.
+ * @y: y coordinate of upper left corner of update region.
+ * @width: Width of update region.
+ * @height: Height of update region.
  *
- * Free the specified drawable's shadow data (if it exists).
+ * Update the specified region of the drawable.
  *
- * This procedure is intended as a memory saving device. If any shadow
- * memory has been allocated, it will be freed automatically when the
- * drawable is removed from the image, or when the plug-in procedure
- * which allocated it returns.
+ * This procedure updates the specified region of the drawable. The (x,
+ * y) coordinate pair is relative to the drawable's origin, not to the
+ * image origin. Therefore, the entire drawable can be updated using
+ * (0, 0, width, height).
  *
  * Returns: TRUE on success.
- *
- * Since: 2.6
  **/
 gboolean
-gimp_drawable_free_shadow (gint32 drawable_ID)
+gimp_drawable_update (GimpDrawable *drawable,
+                      gint          x,
+                      gint          y,
+                      gint          width,
+                      gint          height)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -728,15 +1490,19 @@ gimp_drawable_free_shadow (gint32 drawable_ID)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, x,
+                                          G_TYPE_INT, y,
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-free-shadow",
+                                                "gimp-drawable-update",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-free-shadow",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-update",
                                             args);
   gimp_value_array_unref (args);
 
@@ -748,7 +1514,7 @@ gimp_drawable_free_shadow (gint32 drawable_ID)
 }
 
 /**
- * gimp_drawable_update:
+ * _gimp_drawable_update: (skip)
  * @drawable_ID: The drawable.
  * @x: x coordinate of upper left corner of update region.
  * @y: y coordinate of upper left corner of update region.
@@ -765,11 +1531,11 @@ gimp_drawable_free_shadow (gint32 drawable_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_update (gint32 drawable_ID,
-                      gint   x,
-                      gint   y,
-                      gint   width,
-                      gint   height)
+_gimp_drawable_update (gint32 drawable_ID,
+                       gint   x,
+                       gint   y,
+                       gint   width,
+                       gint   height)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -802,7 +1568,7 @@ gimp_drawable_update (gint32 drawable_ID,
 
 /**
  * gimp_drawable_get_pixel:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  * @x_coord: The x coordinate.
  * @y_coord: The y coordinate.
  * @num_channels: (out): The number of channels for the pixel.
@@ -818,10 +1584,65 @@ gimp_drawable_update (gint32 drawable_ID,
  *          The returned value must be freed with g_free().
  **/
 guint8 *
-gimp_drawable_get_pixel (gint32  drawable_ID,
-                         gint    x_coord,
-                         gint    y_coord,
-                         gint   *num_channels)
+gimp_drawable_get_pixel (GimpDrawable *drawable,
+                         gint          x_coord,
+                         gint          y_coord,
+                         gint         *num_channels)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  guint8 *pixel = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, x_coord,
+                                          G_TYPE_INT, y_coord,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-get-pixel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-get-pixel",
+                                            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));
+      pixel = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return pixel;
+}
+
+/**
+ * _gimp_drawable_get_pixel: (skip)
+ * @drawable_ID: The drawable.
+ * @x_coord: The x coordinate.
+ * @y_coord: The y coordinate.
+ * @num_channels: (out): The number of channels for the pixel.
+ *
+ * Gets the value of the pixel at the specified coordinates.
+ *
+ * This procedure gets the pixel value at the specified coordinates.
+ * The 'num_channels' argument must always be equal to the
+ * bytes-per-pixel value for the specified drawable.
+ *
+ * Returns: (array length=num_channels): The pixel value.
+ *          The returned value must be freed with g_free().
+ **/
+guint8 *
+_gimp_drawable_get_pixel (gint32  drawable_ID,
+                          gint    x_coord,
+                          gint    y_coord,
+                          gint   *num_channels)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -858,28 +1679,138 @@ gimp_drawable_get_pixel (gint32  drawable_ID,
 
 /**
  * gimp_drawable_set_pixel:
+ * @drawable: The drawable.
+ * @x_coord: The x coordinate.
+ * @y_coord: The y coordinate.
+ * @num_channels: The number of channels for the pixel.
+ * @pixel: (array length=num_channels) (element-type guint8): The pixel value.
+ *
+ * Sets the value of the pixel at the specified coordinates.
+ *
+ * This procedure sets the pixel value at the specified coordinates.
+ * The 'num_channels' argument must always be equal to the
+ * bytes-per-pixel value for the specified drawable. Note that this
+ * function is not undoable, you should use it only on drawables you
+ * just created yourself.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_set_pixel (GimpDrawable *drawable,
+                         gint          x_coord,
+                         gint          y_coord,
+                         gint          num_channels,
+                         const guint8 *pixel)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, x_coord,
+                                          G_TYPE_INT, y_coord,
+                                          G_TYPE_INT, num_channels,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 4), pixel, num_channels);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-set-pixel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-set-pixel",
+                                            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_drawable_set_pixel: (skip)
  * @drawable_ID: The drawable.
  * @x_coord: The x coordinate.
  * @y_coord: The y coordinate.
  * @num_channels: The number of channels for the pixel.
  * @pixel: (array length=num_channels) (element-type guint8): The pixel value.
  *
- * Sets the value of the pixel at the specified coordinates.
+ * Sets the value of the pixel at the specified coordinates.
+ *
+ * This procedure sets the pixel value at the specified coordinates.
+ * The 'num_channels' argument must always be equal to the
+ * bytes-per-pixel value for the specified drawable. Note that this
+ * function is not undoable, you should use it only on drawables you
+ * just created yourself.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_drawable_set_pixel (gint32        drawable_ID,
+                          gint          x_coord,
+                          gint          y_coord,
+                          gint          num_channels,
+                          const guint8 *pixel)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, x_coord,
+                                          G_TYPE_INT, y_coord,
+                                          G_TYPE_INT, num_channels,
+                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_uint8_array (gimp_value_array_index (args, 4), pixel, num_channels);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-set-pixel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-set-pixel",
+                                            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_drawable_fill:
+ * @drawable: The drawable.
+ * @fill_type: The type of fill.
+ *
+ * Fill the drawable with the specified fill mode.
  *
- * This procedure sets the pixel value at the specified coordinates.
- * The 'num_channels' argument must always be equal to the
- * bytes-per-pixel value for the specified drawable. Note that this
- * function is not undoable, you should use it only on drawables you
- * just created yourself.
+ * This procedure fills the drawable. If the fill mode is foreground
+ * the current foreground color is used. If the fill mode is
+ * background, the current background color is used. If the fill type
+ * is white, then white is used. Transparent fill only affects layers
+ * with an alpha channel, in which case the alpha channel is set to
+ * transparent. If the drawable has no alpha channel, it is filled to
+ * white. No fill leaves the drawable's contents undefined.
+ * This procedure is unlike gimp_edit_fill() or the bucket fill tool
+ * because it fills regardless of a selection. Its main purpose is to
+ * fill a newly created drawable before adding it to the image. This
+ * operation cannot be undone.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_set_pixel (gint32        drawable_ID,
-                         gint          x_coord,
-                         gint          y_coord,
-                         gint          num_channels,
-                         const guint8 *pixel)
+gimp_drawable_fill (GimpDrawable *drawable,
+                    GimpFillType  fill_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -887,20 +1818,16 @@ gimp_drawable_set_pixel (gint32        drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_INT, x_coord,
-                                          G_TYPE_INT, y_coord,
-                                          G_TYPE_INT, num_channels,
-                                          GIMP_TYPE_UINT8_ARRAY, NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
                                           G_TYPE_NONE);
-  gimp_value_set_uint8_array (gimp_value_array_index (args, 4), pixel, num_channels);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-set-pixel",
+                                                "gimp-drawable-fill",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-set-pixel",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-fill",
                                             args);
   gimp_value_array_unref (args);
 
@@ -912,7 +1839,7 @@ gimp_drawable_set_pixel (gint32        drawable_ID,
 }
 
 /**
- * gimp_drawable_fill:
+ * _gimp_drawable_fill: (skip)
  * @drawable_ID: The drawable.
  * @fill_type: The type of fill.
  *
@@ -933,8 +1860,8 @@ gimp_drawable_set_pixel (gint32        drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_fill (gint32       drawable_ID,
-                    GimpFillType fill_type)
+_gimp_drawable_fill (gint32       drawable_ID,
+                     GimpFillType fill_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -964,6 +1891,62 @@ gimp_drawable_fill (gint32       drawable_ID,
 
 /**
  * gimp_drawable_offset:
+ * @drawable: The drawable to offset.
+ * @wrap_around: wrap image around or fill vacated regions.
+ * @fill_type: fill vacated regions of drawable with background or transparent.
+ * @offset_x: offset by this amount in X direction.
+ * @offset_y: offset by this amount in Y direction.
+ *
+ * Offset the drawable by the specified amounts in the X and Y
+ * directions
+ *
+ * This procedure offsets the specified drawable by the amounts
+ * specified by 'offset_x' and 'offset_y'. If 'wrap_around' is set to
+ * TRUE, then portions of the drawable which are offset out of bounds
+ * are wrapped around. Alternatively, the undefined regions of the
+ * drawable can be filled with transparency or the background color, as
+ * specified by the 'fill-type' parameter.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_offset (GimpDrawable   *drawable,
+                      gboolean        wrap_around,
+                      GimpOffsetType  fill_type,
+                      gint            offset_x,
+                      gint            offset_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_BOOLEAN, wrap_around,
+                                          GIMP_TYPE_OFFSET_TYPE, fill_type,
+                                          G_TYPE_INT, offset_x,
+                                          G_TYPE_INT, offset_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-offset",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_offset: (skip)
  * @drawable_ID: The drawable to offset.
  * @wrap_around: wrap image around or fill vacated regions.
  * @fill_type: fill vacated regions of drawable with background or transparent.
@@ -983,11 +1966,11 @@ gimp_drawable_fill (gint32       drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_offset (gint32         drawable_ID,
-                      gboolean       wrap_around,
-                      GimpOffsetType fill_type,
-                      gint           offset_x,
-                      gint           offset_y)
+_gimp_drawable_offset (gint32         drawable_ID,
+                       gboolean       wrap_around,
+                       GimpOffsetType fill_type,
+                       gint           offset_x,
+                       gint           offset_y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1020,7 +2003,7 @@ gimp_drawable_offset (gint32         drawable_ID,
 
 /**
  * _gimp_drawable_thumbnail:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  * @width: The requested thumbnail width.
  * @height: The requested thumbnail height.
  * @actual_width: (out): The previews width.
@@ -1039,14 +2022,86 @@ gimp_drawable_offset (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-_gimp_drawable_thumbnail (gint32   drawable_ID,
-                          gint     width,
-                          gint     height,
-                          gint    *actual_width,
-                          gint    *actual_height,
-                          gint    *bpp,
-                          gint    *thumbnail_data_count,
-                          guint8 **thumbnail_data)
+_gimp_drawable_thumbnail (GimpDrawable  *drawable,
+                          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_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, width,
+                                          G_TYPE_INT, height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-thumbnail",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_thumbnail: (skip)
+ * @drawable_ID: The drawable.
+ * @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 a drawable.
+ *
+ * This function gets data from which a thumbnail of a drawable 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 bytes in the image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+__gimp_drawable_thumbnail (gint32   drawable_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;
@@ -1092,7 +2147,7 @@ _gimp_drawable_thumbnail (gint32   drawable_ID,
 
 /**
  * _gimp_drawable_sub_thumbnail:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  * @src_x: The x coordinate of the area.
  * @src_y: The y coordinate of the area.
  * @src_width: The width of the area.
@@ -1117,18 +2172,104 @@ _gimp_drawable_thumbnail (gint32   drawable_ID,
  * Since: 2.2
  **/
 gboolean
-_gimp_drawable_sub_thumbnail (gint32   drawable_ID,
-                              gint     src_x,
-                              gint     src_y,
-                              gint     src_width,
-                              gint     src_height,
-                              gint     dest_width,
-                              gint     dest_height,
-                              gint    *width,
-                              gint    *height,
-                              gint    *bpp,
-                              gint    *thumbnail_data_count,
-                              guint8 **thumbnail_data)
+_gimp_drawable_sub_thumbnail (GimpDrawable  *drawable,
+                              gint           src_x,
+                              gint           src_y,
+                              gint           src_width,
+                              gint           src_height,
+                              gint           dest_width,
+                              gint           dest_height,
+                              gint          *width,
+                              gint          *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_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, src_x,
+                                          G_TYPE_INT, src_y,
+                                          G_TYPE_INT, src_width,
+                                          G_TYPE_INT, src_height,
+                                          G_TYPE_INT, dest_width,
+                                          G_TYPE_INT, dest_height,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-sub-thumbnail",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-sub-thumbnail",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *width = 0;
+  *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)
+    {
+      *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      *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_drawable_sub_thumbnail: (skip)
+ * @drawable_ID: The drawable.
+ * @src_x: The x coordinate of the area.
+ * @src_y: The y coordinate of the area.
+ * @src_width: The width of the area.
+ * @src_height: The height of the area.
+ * @dest_width: The thumbnail width.
+ * @dest_height: The thumbnail height.
+ * @width: (out): The previews width.
+ * @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 a sub-area of a drawable drawable.
+ *
+ * This function gets data from which a thumbnail of a drawable 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 bytes in the image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.2
+ **/
+gboolean
+__gimp_drawable_sub_thumbnail (gint32   drawable_ID,
+                               gint     src_x,
+                               gint     src_y,
+                               gint     src_width,
+                               gint     src_height,
+                               gint     dest_width,
+                               gint     dest_height,
+                               gint    *width,
+                               gint    *height,
+                               gint    *bpp,
+                               gint    *thumbnail_data_count,
+                               guint8 **thumbnail_data)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1178,6 +2319,53 @@ _gimp_drawable_sub_thumbnail (gint32   drawable_ID,
 
 /**
  * gimp_drawable_foreground_extract:
+ * @drawable: The drawable.
+ * @mode: The algorithm to use.
+ * @mask: Tri-Map.
+ *
+ * Extract the foreground of a drawable using a given trimap.
+ *
+ * Image Segmentation by Uniform Color Clustering, see
+ * https://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_drawable_foreground_extract (GimpDrawable              *drawable,
+                                  GimpForegroundExtractMode  mode,
+                                  GimpDrawable              *mask)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_FOREGROUND_EXTRACT_MODE, mode,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (mask)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-foreground-extract",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-foreground-extract",
+                                            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_drawable_foreground_extract: (skip)
  * @drawable_ID: The drawable.
  * @mode: The algorithm to use.
  * @mask_ID: Tri-Map.
@@ -1192,9 +2380,9 @@ _gimp_drawable_sub_thumbnail (gint32   drawable_ID,
  * Since: 2.4
  **/
 gboolean
-gimp_drawable_foreground_extract (gint32                    drawable_ID,
-                                  GimpForegroundExtractMode mode,
-                                  gint32                    mask_ID)
+_gimp_drawable_foreground_extract (gint32                    drawable_ID,
+                                   GimpForegroundExtractMode mode,
+                                   gint32                    mask_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpdrawable_pdb.h b/libgimp/gimpdrawable_pdb.h
index 6916584eeb..56e54f4f10 100644
--- a/libgimp/gimpdrawable_pdb.h
+++ b/libgimp/gimpdrawable_pdb.h
@@ -32,55 +32,59 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-G_GNUC_INTERNAL gchar*   _gimp_drawable_get_format           (gint32                      drawable_ID);
-G_GNUC_INTERNAL gchar*   _gimp_drawable_get_thumbnail_format (gint32                      drawable_ID);
-GimpImageType            gimp_drawable_type                  (gint32                      drawable_ID);
-GimpImageType            gimp_drawable_type_with_alpha       (gint32                      drawable_ID);
-gboolean                 gimp_drawable_has_alpha             (gint32                      drawable_ID);
-gboolean                 gimp_drawable_is_rgb                (gint32                      drawable_ID);
-gboolean                 gimp_drawable_is_gray               (gint32                      drawable_ID);
-gboolean                 gimp_drawable_is_indexed            (gint32                      drawable_ID);
-gint                     gimp_drawable_bpp                   (gint32                      drawable_ID);
-gint                     gimp_drawable_width                 (gint32                      drawable_ID);
-gint                     gimp_drawable_height                (gint32                      drawable_ID);
-gboolean                 gimp_drawable_offsets               (gint32                      drawable_ID,
+
+
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
+
+G_GNUC_INTERNAL gchar*   _gimp_drawable_get_format           (GimpDrawable               *drawable);
+G_GNUC_INTERNAL gchar*   _gimp_drawable_get_thumbnail_format (GimpDrawable               *drawable);
+GimpImageType            gimp_drawable_type                  (GimpDrawable               *drawable);
+GimpImageType            gimp_drawable_type_with_alpha       (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_has_alpha             (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_is_rgb                (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_is_gray               (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_is_indexed            (GimpDrawable               *drawable);
+gint                     gimp_drawable_bpp                   (GimpDrawable               *drawable);
+gint                     gimp_drawable_width                 (GimpDrawable               *drawable);
+gint                     gimp_drawable_height                (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_offsets               (GimpDrawable               *drawable,
                                                               gint                       *offset_x,
                                                               gint                       *offset_y);
-gboolean                 gimp_drawable_mask_bounds           (gint32                      drawable_ID,
+gboolean                 gimp_drawable_mask_bounds           (GimpDrawable               *drawable,
                                                               gint                       *x1,
                                                               gint                       *y1,
                                                               gint                       *x2,
                                                               gint                       *y2);
-gboolean                 gimp_drawable_mask_intersect        (gint32                      drawable_ID,
+gboolean                 gimp_drawable_mask_intersect        (GimpDrawable               *drawable,
                                                               gint                       *x,
                                                               gint                       *y,
                                                               gint                       *width,
                                                               gint                       *height);
-gboolean                 gimp_drawable_merge_shadow          (gint32                      drawable_ID,
+gboolean                 gimp_drawable_merge_shadow          (GimpDrawable               *drawable,
                                                               gboolean                    undo);
-gboolean                 gimp_drawable_free_shadow           (gint32                      drawable_ID);
-gboolean                 gimp_drawable_update                (gint32                      drawable_ID,
+gboolean                 gimp_drawable_free_shadow           (GimpDrawable               *drawable);
+gboolean                 gimp_drawable_update                (GimpDrawable               *drawable,
                                                               gint                        x,
                                                               gint                        y,
                                                               gint                        width,
                                                               gint                        height);
-guint8*                  gimp_drawable_get_pixel             (gint32                      drawable_ID,
+guint8*                  gimp_drawable_get_pixel             (GimpDrawable               *drawable,
                                                               gint                        x_coord,
                                                               gint                        y_coord,
                                                               gint                       *num_channels);
-gboolean                 gimp_drawable_set_pixel             (gint32                      drawable_ID,
+gboolean                 gimp_drawable_set_pixel             (GimpDrawable               *drawable,
                                                               gint                        x_coord,
                                                               gint                        y_coord,
                                                               gint                        num_channels,
                                                               const guint8               *pixel);
-gboolean                 gimp_drawable_fill                  (gint32                      drawable_ID,
+gboolean                 gimp_drawable_fill                  (GimpDrawable               *drawable,
                                                               GimpFillType                fill_type);
-gboolean                 gimp_drawable_offset                (gint32                      drawable_ID,
+gboolean                 gimp_drawable_offset                (GimpDrawable               *drawable,
                                                               gboolean                    wrap_around,
                                                               GimpOffsetType              fill_type,
                                                               gint                        offset_x,
                                                               gint                        offset_y);
-G_GNUC_INTERNAL gboolean _gimp_drawable_thumbnail            (gint32                      drawable_ID,
+G_GNUC_INTERNAL gboolean _gimp_drawable_thumbnail            (GimpDrawable               *drawable,
                                                               gint                        width,
                                                               gint                        height,
                                                               gint                       *actual_width,
@@ -88,7 +92,7 @@ G_GNUC_INTERNAL gboolean _gimp_drawable_thumbnail            (gint32
                                                               gint                       *bpp,
                                                               gint                       
*thumbnail_data_count,
                                                               guint8                    **thumbnail_data);
-G_GNUC_INTERNAL gboolean _gimp_drawable_sub_thumbnail        (gint32                      drawable_ID,
+G_GNUC_INTERNAL gboolean _gimp_drawable_sub_thumbnail        (GimpDrawable               *drawable,
                                                               gint                        src_x,
                                                               gint                        src_y,
                                                               gint                        src_width,
@@ -100,16 +104,36 @@ G_GNUC_INTERNAL gboolean _gimp_drawable_sub_thumbnail        (gint32
                                                               gint                       *bpp,
                                                               gint                       
*thumbnail_data_count,
                                                               guint8                    **thumbnail_data);
-gboolean                 gimp_drawable_foreground_extract    (gint32                      drawable_ID,
+gboolean                 gimp_drawable_foreground_extract    (GimpDrawable               *drawable,
                                                               GimpForegroundExtractMode   mode,
-                                                              gint32                      mask_ID);
-
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
-
-
+                                                              GimpDrawable               *mask);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define _gimp_drawable_get_format __gimp_drawable_get_format
+#define _gimp_drawable_get_thumbnail_format __gimp_drawable_get_thumbnail_format
+#define gimp_drawable_type _gimp_drawable_type
+#define gimp_drawable_type_with_alpha _gimp_drawable_type_with_alpha
+#define gimp_drawable_has_alpha _gimp_drawable_has_alpha
+#define gimp_drawable_is_rgb _gimp_drawable_is_rgb
+#define gimp_drawable_is_gray _gimp_drawable_is_gray
+#define gimp_drawable_is_indexed _gimp_drawable_is_indexed
+#define gimp_drawable_bpp _gimp_drawable_bpp
+#define gimp_drawable_width _gimp_drawable_width
+#define gimp_drawable_height _gimp_drawable_height
+#define gimp_drawable_offsets _gimp_drawable_offsets
+#define gimp_drawable_mask_bounds _gimp_drawable_mask_bounds
+#define gimp_drawable_mask_intersect _gimp_drawable_mask_intersect
+#define gimp_drawable_merge_shadow _gimp_drawable_merge_shadow
+#define gimp_drawable_free_shadow _gimp_drawable_free_shadow
+#define gimp_drawable_update _gimp_drawable_update
+#define gimp_drawable_get_pixel _gimp_drawable_get_pixel
+#define gimp_drawable_set_pixel _gimp_drawable_set_pixel
+#define gimp_drawable_fill _gimp_drawable_fill
+#define gimp_drawable_offset _gimp_drawable_offset
+#define _gimp_drawable_thumbnail __gimp_drawable_thumbnail
+#define _gimp_drawable_sub_thumbnail __gimp_drawable_sub_thumbnail
+#define gimp_drawable_foreground_extract _gimp_drawable_foreground_extract
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -118,7 +142,77 @@ gboolean                 gimp_drawable_foreground_extract    (gint32
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gchar*        __gimp_drawable_get_format           (gint32                      drawable_ID);
+gchar*        __gimp_drawable_get_thumbnail_format (gint32                      drawable_ID);
+GimpImageType _gimp_drawable_type                  (gint32                      drawable_ID);
+GimpImageType _gimp_drawable_type_with_alpha       (gint32                      drawable_ID);
+gboolean      _gimp_drawable_has_alpha             (gint32                      drawable_ID);
+gboolean      _gimp_drawable_is_rgb                (gint32                      drawable_ID);
+gboolean      _gimp_drawable_is_gray               (gint32                      drawable_ID);
+gboolean      _gimp_drawable_is_indexed            (gint32                      drawable_ID);
+gint          _gimp_drawable_bpp                   (gint32                      drawable_ID);
+gint          _gimp_drawable_width                 (gint32                      drawable_ID);
+gint          _gimp_drawable_height                (gint32                      drawable_ID);
+gboolean      _gimp_drawable_offsets               (gint32                      drawable_ID,
+                                                    gint                       *offset_x,
+                                                    gint                       *offset_y);
+gboolean      _gimp_drawable_mask_bounds           (gint32                      drawable_ID,
+                                                    gint                       *x1,
+                                                    gint                       *y1,
+                                                    gint                       *x2,
+                                                    gint                       *y2);
+gboolean      _gimp_drawable_mask_intersect        (gint32                      drawable_ID,
+                                                    gint                       *x,
+                                                    gint                       *y,
+                                                    gint                       *width,
+                                                    gint                       *height);
+gboolean      _gimp_drawable_merge_shadow          (gint32                      drawable_ID,
+                                                    gboolean                    undo);
+gboolean      _gimp_drawable_free_shadow           (gint32                      drawable_ID);
+gboolean      _gimp_drawable_update                (gint32                      drawable_ID,
+                                                    gint                        x,
+                                                    gint                        y,
+                                                    gint                        width,
+                                                    gint                        height);
+guint8*       _gimp_drawable_get_pixel             (gint32                      drawable_ID,
+                                                    gint                        x_coord,
+                                                    gint                        y_coord,
+                                                    gint                       *num_channels);
+gboolean      _gimp_drawable_set_pixel             (gint32                      drawable_ID,
+                                                    gint                        x_coord,
+                                                    gint                        y_coord,
+                                                    gint                        num_channels,
+                                                    const guint8               *pixel);
+gboolean      _gimp_drawable_fill                  (gint32                      drawable_ID,
+                                                    GimpFillType                fill_type);
+gboolean      _gimp_drawable_offset                (gint32                      drawable_ID,
+                                                    gboolean                    wrap_around,
+                                                    GimpOffsetType              fill_type,
+                                                    gint                        offset_x,
+                                                    gint                        offset_y);
+gboolean      __gimp_drawable_thumbnail            (gint32                      drawable_ID,
+                                                    gint                        width,
+                                                    gint                        height,
+                                                    gint                       *actual_width,
+                                                    gint                       *actual_height,
+                                                    gint                       *bpp,
+                                                    gint                       *thumbnail_data_count,
+                                                    guint8                    **thumbnail_data);
+gboolean      __gimp_drawable_sub_thumbnail        (gint32                      drawable_ID,
+                                                    gint                        src_x,
+                                                    gint                        src_y,
+                                                    gint                        src_width,
+                                                    gint                        src_height,
+                                                    gint                        dest_width,
+                                                    gint                        dest_height,
+                                                    gint                       *width,
+                                                    gint                       *height,
+                                                    gint                       *bpp,
+                                                    gint                       *thumbnail_data_count,
+                                                    guint8                    **thumbnail_data);
+gboolean      _gimp_drawable_foreground_extract    (gint32                      drawable_ID,
+                                                    GimpForegroundExtractMode   mode,
+                                                    gint32                      mask_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c
index f5576c17e7..b472e694c0 100644
--- a/libgimp/gimpdrawablecolor_pdb.c
+++ b/libgimp/gimpdrawablecolor_pdb.c
@@ -37,6 +37,54 @@
 
 /**
  * gimp_drawable_brightness_contrast:
+ * @drawable: The drawable.
+ * @brightness: Brightness adjustment.
+ * @contrast: Contrast adjustment.
+ *
+ * Modify brightness/contrast in the specified drawable.
+ *
+ * This procedures allows the brightness and contrast of the specified
+ * drawable to be modified. Both 'brightness' and 'contrast' parameters
+ * are defined between -0.5 and 0.5.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_brightness_contrast (GimpDrawable *drawable,
+                                   gdouble       brightness,
+                                   gdouble       contrast)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, brightness,
+                                          G_TYPE_DOUBLE, contrast,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-brightness-contrast",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-brightness-contrast",
+                                            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_drawable_brightness_contrast: (skip)
  * @drawable_ID: The drawable.
  * @brightness: Brightness adjustment.
  * @contrast: Contrast adjustment.
@@ -52,9 +100,9 @@
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_brightness_contrast (gint32  drawable_ID,
-                                   gdouble brightness,
-                                   gdouble contrast)
+_gimp_drawable_brightness_contrast (gint32  drawable_ID,
+                                    gdouble brightness,
+                                    gdouble contrast)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -85,6 +133,68 @@ gimp_drawable_brightness_contrast (gint32  drawable_ID,
 
 /**
  * gimp_drawable_color_balance:
+ * @drawable: The drawable.
+ * @transfer_mode: Transfer mode.
+ * @preserve_lum: Preserve luminosity values at each pixel.
+ * @cyan_red: Cyan-Red color balance.
+ * @magenta_green: Magenta-Green color balance.
+ * @yellow_blue: Yellow-Blue color balance.
+ *
+ * Modify the color balance of the specified drawable.
+ *
+ * Modify the color balance of the specified drawable. There are three
+ * axis which can be modified: cyan-red, magenta-green, and
+ * yellow-blue. Negative values increase the amount of the former,
+ * positive values increase the amount of the latter. Color balance can
+ * be controlled with the 'transfer_mode' setting, which allows
+ * shadows, mid-tones, and highlights in an image to be affected
+ * differently. The 'preserve-lum' parameter, if TRUE, ensures that the
+ * luminosity of each pixel remains fixed.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_color_balance (GimpDrawable     *drawable,
+                             GimpTransferMode  transfer_mode,
+                             gboolean          preserve_lum,
+                             gdouble           cyan_red,
+                             gdouble           magenta_green,
+                             gdouble           yellow_blue)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_TRANSFER_MODE, transfer_mode,
+                                          G_TYPE_BOOLEAN, preserve_lum,
+                                          G_TYPE_DOUBLE, cyan_red,
+                                          G_TYPE_DOUBLE, magenta_green,
+                                          G_TYPE_DOUBLE, yellow_blue,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-color-balance",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-color-balance",
+                                            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_drawable_color_balance: (skip)
  * @drawable_ID: The drawable.
  * @transfer_mode: Transfer mode.
  * @preserve_lum: Preserve luminosity values at each pixel.
@@ -108,12 +218,12 @@ gimp_drawable_brightness_contrast (gint32  drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_color_balance (gint32           drawable_ID,
-                             GimpTransferMode transfer_mode,
-                             gboolean         preserve_lum,
-                             gdouble          cyan_red,
-                             gdouble          magenta_green,
-                             gdouble          yellow_blue)
+_gimp_drawable_color_balance (gint32           drawable_ID,
+                              GimpTransferMode transfer_mode,
+                              gboolean         preserve_lum,
+                              gdouble          cyan_red,
+                              gdouble          magenta_green,
+                              gdouble          yellow_blue)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -147,6 +257,58 @@ gimp_drawable_color_balance (gint32           drawable_ID,
 
 /**
  * gimp_drawable_colorize_hsl:
+ * @drawable: The drawable.
+ * @hue: Hue in degrees.
+ * @saturation: Saturation in percent.
+ * @lightness: Lightness in percent.
+ *
+ * Render the drawable as a grayscale image seen through a colored
+ * glass.
+ *
+ * Desaturates the drawable, then tints it with the specified color.
+ * This tool is only valid on RGB color images. It will not operate on
+ * grayscale drawables.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_colorize_hsl (GimpDrawable *drawable,
+                            gdouble       hue,
+                            gdouble       saturation,
+                            gdouble       lightness)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, hue,
+                                          G_TYPE_DOUBLE, saturation,
+                                          G_TYPE_DOUBLE, lightness,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-colorize-hsl",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-colorize-hsl",
+                                            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_drawable_colorize_hsl: (skip)
  * @drawable_ID: The drawable.
  * @hue: Hue in degrees.
  * @saturation: Saturation in percent.
@@ -164,10 +326,10 @@ gimp_drawable_color_balance (gint32           drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_colorize_hsl (gint32  drawable_ID,
-                            gdouble hue,
-                            gdouble saturation,
-                            gdouble lightness)
+_gimp_drawable_colorize_hsl (gint32  drawable_ID,
+                             gdouble hue,
+                             gdouble saturation,
+                             gdouble lightness)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -199,7 +361,7 @@ gimp_drawable_colorize_hsl (gint32  drawable_ID,
 
 /**
  * gimp_drawable_curves_explicit:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  * @channel: The channel to modify.
  * @num_values: The number of values in the new curve.
  * @values: (array length=num_values) (element-type gdouble): The explicit curve.
@@ -218,7 +380,7 @@ gimp_drawable_colorize_hsl (gint32  drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_curves_explicit (gint32                drawable_ID,
+gimp_drawable_curves_explicit (GimpDrawable         *drawable,
                                GimpHistogramChannel  channel,
                                gint                  num_values,
                                const gdouble        *values)
@@ -228,6 +390,61 @@ gimp_drawable_curves_explicit (gint32                drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_INT, num_values,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), values, num_values);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-curves-explicit",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-curves-explicit",
+                                            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_drawable_curves_explicit: (skip)
+ * @drawable_ID: The drawable.
+ * @channel: The channel to modify.
+ * @num_values: The number of values in the new curve.
+ * @values: (array length=num_values) (element-type gdouble): The explicit curve.
+ *
+ * Modifies the intensity curve(s) for specified drawable.
+ *
+ * Modifies the intensity mapping for one channel in the specified
+ * drawable. The channel can be either an intensity component, or the
+ * value. The 'values' parameter is an array of doubles which
+ * explicitly defines how each pixel value in the drawable will be
+ * modified. Use the gimp_curves_spline() function to modify intensity
+ * levels with Catmull Rom splines.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_drawable_curves_explicit (gint32                drawable_ID,
+                                GimpHistogramChannel  channel,
+                                gint                  num_values,
+                                const gdouble        *values)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
@@ -254,7 +471,7 @@ gimp_drawable_curves_explicit (gint32                drawable_ID,
 
 /**
  * gimp_drawable_curves_spline:
- * @drawable_ID: The drawable.
+ * @drawable: The drawable.
  * @channel: The channel to modify.
  * @num_points: The number of values in the control point array.
  * @points: (array length=num_points) (element-type gdouble): The spline control points: { cp1.x, cp1.y, 
cp2.x, cp2.y, ... }.
@@ -273,7 +490,7 @@ gimp_drawable_curves_explicit (gint32                drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_curves_spline (gint32                drawable_ID,
+gimp_drawable_curves_spline (GimpDrawable         *drawable,
                              GimpHistogramChannel  channel,
                              gint                  num_points,
                              const gdouble        *points)
@@ -284,7 +501,7 @@ gimp_drawable_curves_spline (gint32                drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
                                           G_TYPE_INT, num_points,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
@@ -308,24 +525,30 @@ gimp_drawable_curves_spline (gint32                drawable_ID,
 }
 
 /**
- * gimp_drawable_desaturate:
+ * _gimp_drawable_curves_spline: (skip)
  * @drawable_ID: The drawable.
- * @desaturate_mode: The formula to use to desaturate.
+ * @channel: The channel to modify.
+ * @num_points: The number of values in the control point array.
+ * @points: (array length=num_points) (element-type gdouble): The spline control points: { cp1.x, cp1.y, 
cp2.x, cp2.y, ... }.
  *
- * Desaturate the contents of the specified drawable, with the
- * specified formula.
+ * Modifies the intensity curve(s) for specified drawable.
  *
- * This procedure desaturates the contents of the specified drawable,
- * with the specified formula. This procedure only works on drawables
- * of type RGB color.
+ * Modifies the intensity mapping for one channel in the specified
+ * drawable. The channel can be either an intensity component, or the
+ * value. The 'points' parameter is an array of doubles which define a
+ * set of control points which describe a Catmull Rom spline which
+ * yields the final intensity curve. Use the gimp_curves_explicit()
+ * function to explicitly modify intensity levels.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_desaturate (gint32             drawable_ID,
-                          GimpDesaturateMode desaturate_mode)
+_gimp_drawable_curves_spline (gint32                drawable_ID,
+                              GimpHistogramChannel  channel,
+                              gint                  num_points,
+                              const gdouble        *points)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -334,15 +557,18 @@ gimp_drawable_desaturate (gint32             drawable_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          GIMP_TYPE_DESATURATE_MODE, desaturate_mode,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_INT, num_points,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), points, num_points);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-desaturate",
+                                                "gimp-drawable-curves-spline",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-desaturate",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-curves-spline",
                                             args);
   gimp_value_array_unref (args);
 
@@ -354,27 +580,24 @@ gimp_drawable_desaturate (gint32             drawable_ID,
 }
 
 /**
- * gimp_drawable_equalize:
- * @drawable_ID: The drawable.
- * @mask_only: Equalization option.
+ * gimp_drawable_desaturate:
+ * @drawable: The drawable.
+ * @desaturate_mode: The formula to use to desaturate.
  *
- * Equalize the contents of the specified drawable.
+ * Desaturate the contents of the specified drawable, with the
+ * specified formula.
  *
- * This procedure equalizes the contents of the specified drawable.
- * Each intensity channel is equalized independently. The equalized
- * intensity is given as inten' = (255 - inten). The 'mask_only' option
- * specifies whether to adjust only the area of the image within the
- * selection bounds, or the entire image based on the histogram of the
- * selected area. If there is no selection, the entire image is
- * adjusted based on the histogram for the entire image.
+ * This procedure desaturates the contents of the specified drawable,
+ * with the specified formula. This procedure only works on drawables
+ * of type RGB color.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_equalize (gint32   drawable_ID,
-                        gboolean mask_only)
+gimp_drawable_desaturate (GimpDrawable       *drawable,
+                          GimpDesaturateMode  desaturate_mode)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -382,16 +605,16 @@ gimp_drawable_equalize (gint32   drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_BOOLEAN, mask_only,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_DESATURATE_MODE, desaturate_mode,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-drawable-equalize",
+                                                "gimp-drawable-desaturate",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-equalize",
+    return_vals = gimp_run_procedure_array ("gimp-drawable-desaturate",
                                             args);
   gimp_value_array_unref (args);
 
@@ -403,20 +626,164 @@ gimp_drawable_equalize (gint32   drawable_ID,
 }
 
 /**
- * gimp_drawable_histogram:
+ * _gimp_drawable_desaturate: (skip)
  * @drawable_ID: The drawable.
- * @channel: The channel to query.
- * @start_range: Start of the intensity measurement range.
- * @end_range: End of the intensity measurement range.
- * @mean: (out): Mean intensity value.
- * @std_dev: (out): Standard deviation of intensity values.
- * @median: (out): Median intensity value.
- * @pixels: (out): Alpha-weighted pixel count for entire image.
- * @count: (out): Alpha-weighted pixel count for range.
- * @percentile: (out): Percentile that range falls under.
+ * @desaturate_mode: The formula to use to desaturate.
  *
- * Returns information on the intensity histogram for the specified
- * drawable.
+ * Desaturate the contents of the specified drawable, with the
+ * specified formula.
+ *
+ * This procedure desaturates the contents of the specified drawable,
+ * with the specified formula. This procedure only works on drawables
+ * of type RGB color.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_drawable_desaturate (gint32             drawable_ID,
+                           GimpDesaturateMode desaturate_mode)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DESATURATE_MODE, desaturate_mode,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-desaturate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-desaturate",
+                                            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_drawable_equalize:
+ * @drawable: The drawable.
+ * @mask_only: Equalization option.
+ *
+ * Equalize the contents of the specified drawable.
+ *
+ * This procedure equalizes the contents of the specified drawable.
+ * Each intensity channel is equalized independently. The equalized
+ * intensity is given as inten' = (255 - inten). The 'mask_only' option
+ * specifies whether to adjust only the area of the image within the
+ * selection bounds, or the entire image based on the histogram of the
+ * selected area. If there is no selection, the entire image is
+ * adjusted based on the histogram for the entire image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_equalize (GimpDrawable *drawable,
+                        gboolean      mask_only)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_BOOLEAN, mask_only,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-equalize",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-equalize",
+                                            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_drawable_equalize: (skip)
+ * @drawable_ID: The drawable.
+ * @mask_only: Equalization option.
+ *
+ * Equalize the contents of the specified drawable.
+ *
+ * This procedure equalizes the contents of the specified drawable.
+ * Each intensity channel is equalized independently. The equalized
+ * intensity is given as inten' = (255 - inten). The 'mask_only' option
+ * specifies whether to adjust only the area of the image within the
+ * selection bounds, or the entire image based on the histogram of the
+ * selected area. If there is no selection, the entire image is
+ * adjusted based on the histogram for the entire image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_drawable_equalize (gint32   drawable_ID,
+                         gboolean mask_only)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, mask_only,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-equalize",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-equalize",
+                                            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_drawable_histogram:
+ * @drawable: The drawable.
+ * @channel: The channel to query.
+ * @start_range: Start of the intensity measurement range.
+ * @end_range: End of the intensity measurement range.
+ * @mean: (out): Mean intensity value.
+ * @std_dev: (out): Standard deviation of intensity values.
+ * @median: (out): Median intensity value.
+ * @pixels: (out): Alpha-weighted pixel count for entire image.
+ * @count: (out): Alpha-weighted pixel count for range.
+ * @percentile: (out): Percentile that range falls under.
+ *
+ * Returns information on the intensity histogram for the specified
+ * drawable.
  *
  * This tool makes it possible to gather information about the
  * intensity histogram of a drawable. A channel to examine is first
@@ -439,7 +806,7 @@ gimp_drawable_equalize (gint32   drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_histogram (gint32                drawable_ID,
+gimp_drawable_histogram (GimpDrawable         *drawable,
                          GimpHistogramChannel  channel,
                          gdouble               start_range,
                          gdouble               end_range,
@@ -455,6 +822,99 @@ gimp_drawable_histogram (gint32                drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, start_range,
+                                          G_TYPE_DOUBLE, end_range,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-histogram",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-histogram",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *mean = 0.0;
+  *std_dev = 0.0;
+  *median = 0.0;
+  *pixels = 0.0;
+  *count = 0.0;
+  *percentile = 0.0;
+
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+  if (success)
+    {
+      *mean = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *std_dev = g_value_get_double (gimp_value_array_index (return_vals, 2));
+      *median = g_value_get_double (gimp_value_array_index (return_vals, 3));
+      *pixels = g_value_get_double (gimp_value_array_index (return_vals, 4));
+      *count = g_value_get_double (gimp_value_array_index (return_vals, 5));
+      *percentile = g_value_get_double (gimp_value_array_index (return_vals, 6));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return success;
+}
+
+/**
+ * _gimp_drawable_histogram: (skip)
+ * @drawable_ID: The drawable.
+ * @channel: The channel to query.
+ * @start_range: Start of the intensity measurement range.
+ * @end_range: End of the intensity measurement range.
+ * @mean: (out): Mean intensity value.
+ * @std_dev: (out): Standard deviation of intensity values.
+ * @median: (out): Median intensity value.
+ * @pixels: (out): Alpha-weighted pixel count for entire image.
+ * @count: (out): Alpha-weighted pixel count for range.
+ * @percentile: (out): Percentile that range falls under.
+ *
+ * Returns information on the intensity histogram for the specified
+ * drawable.
+ *
+ * This tool makes it possible to gather information about the
+ * intensity histogram of a drawable. A channel to examine is first
+ * specified. This can be either value, red, green, or blue, depending
+ * on whether the drawable is of type color or grayscale. Second, a
+ * range of intensities are specified. The gimp_drawable_histogram()
+ * function returns statistics based on the pixels in the drawable that
+ * fall under this range of values. Mean, standard deviation, median,
+ * number of pixels, and percentile are all returned. Additionally, the
+ * total count of pixels in the image is returned. Counts of pixels are
+ * weighted by any associated alpha values and by the current selection
+ * mask. That is, pixels that lie outside an active selection mask will
+ * not be counted. Similarly, pixels with transparent alpha values will
+ * not be counted. The returned mean, std_dev and median are in the
+ * range (0..255) for 8-bit images or if the plug-in is not
+ * precision-aware, and in the range (0.0..1.0) otherwise.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_drawable_histogram (gint32                drawable_ID,
+                          GimpHistogramChannel  channel,
+                          gdouble               start_range,
+                          gdouble               end_range,
+                          gdouble              *mean,
+                          gdouble              *std_dev,
+                          gdouble              *median,
+                          gdouble              *pixels,
+                          gdouble              *count,
+                          gdouble              *percentile)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
@@ -497,6 +957,65 @@ gimp_drawable_histogram (gint32                drawable_ID,
 
 /**
  * gimp_drawable_hue_saturation:
+ * @drawable: The drawable.
+ * @hue_range: Range of affected hues.
+ * @hue_offset: Hue offset in degrees.
+ * @lightness: Lightness modification.
+ * @saturation: Saturation modification.
+ * @overlap: Overlap other hue channels.
+ *
+ * Modify hue, lightness, and saturation in the specified drawable.
+ *
+ * This procedure allows the hue, lightness, and saturation in the
+ * specified drawable to be modified. The 'hue-range' parameter
+ * provides the capability to limit range of affected hues. The
+ * 'overlap' parameter provides blending into neighboring hue channels
+ * when rendering.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_hue_saturation (GimpDrawable *drawable,
+                              GimpHueRange  hue_range,
+                              gdouble       hue_offset,
+                              gdouble       lightness,
+                              gdouble       saturation,
+                              gdouble       overlap)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_HUE_RANGE, hue_range,
+                                          G_TYPE_DOUBLE, hue_offset,
+                                          G_TYPE_DOUBLE, lightness,
+                                          G_TYPE_DOUBLE, saturation,
+                                          G_TYPE_DOUBLE, overlap,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-hue-saturation",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-hue-saturation",
+                                            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_drawable_hue_saturation: (skip)
  * @drawable_ID: The drawable.
  * @hue_range: Range of affected hues.
  * @hue_offset: Hue offset in degrees.
@@ -517,12 +1036,12 @@ gimp_drawable_histogram (gint32                drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_hue_saturation (gint32       drawable_ID,
-                              GimpHueRange hue_range,
-                              gdouble      hue_offset,
-                              gdouble      lightness,
-                              gdouble      saturation,
-                              gdouble      overlap)
+_gimp_drawable_hue_saturation (gint32       drawable_ID,
+                               GimpHueRange hue_range,
+                               gdouble      hue_offset,
+                               gdouble      lightness,
+                               gdouble      saturation,
+                               gdouble      overlap)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -556,6 +1075,52 @@ gimp_drawable_hue_saturation (gint32       drawable_ID,
 
 /**
  * gimp_drawable_invert:
+ * @drawable: The drawable.
+ * @linear: Whether to invert in linear space.
+ *
+ * Invert the contents of the specified drawable.
+ *
+ * This procedure inverts the contents of the specified drawable. Each
+ * intensity channel is inverted independently. The inverted intensity
+ * is given as inten' = (255 - inten). If 'linear' is TRUE, the
+ * drawable is inverted in linear space.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_invert (GimpDrawable *drawable,
+                      gboolean      linear)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_BOOLEAN, linear,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-invert",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-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_drawable_invert: (skip)
  * @drawable_ID: The drawable.
  * @linear: Whether to invert in linear space.
  *
@@ -571,8 +1136,8 @@ gimp_drawable_hue_saturation (gint32       drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_invert (gint32   drawable_ID,
-                      gboolean linear)
+_gimp_drawable_invert (gint32   drawable_ID,
+                       gboolean linear)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -602,6 +1167,81 @@ gimp_drawable_invert (gint32   drawable_ID,
 
 /**
  * gimp_drawable_levels:
+ * @drawable: The drawable.
+ * @channel: The channel to modify.
+ * @low_input: Intensity of lowest input.
+ * @high_input: Intensity of highest input.
+ * @clamp_input: Clamp input values before applying output levels.
+ * @gamma: Gamma adjustment factor.
+ * @low_output: Intensity of lowest output.
+ * @high_output: Intensity of highest output.
+ * @clamp_output: Clamp final output values.
+ *
+ * Modifies intensity levels in the specified drawable.
+ *
+ * This tool allows intensity levels in the specified drawable to be
+ * remapped according to a set of parameters. The low/high input levels
+ * specify an initial mapping from the source intensities. The gamma
+ * value determines how intensities between the low and high input
+ * intensities are interpolated. A gamma value of 1.0 results in a
+ * linear interpolation. Higher gamma values result in more high-level
+ * intensities. Lower gamma values result in more low-level
+ * intensities. The low/high output levels constrain the final
+ * intensity mapping--that is, no final intensity will be lower than
+ * the low output level and no final intensity will be higher than the
+ * high output level. This tool is only valid on RGB color and
+ * grayscale images.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_levels (GimpDrawable         *drawable,
+                      GimpHistogramChannel  channel,
+                      gdouble               low_input,
+                      gdouble               high_input,
+                      gboolean              clamp_input,
+                      gdouble               gamma,
+                      gdouble               low_output,
+                      gdouble               high_output,
+                      gboolean              clamp_output)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, low_input,
+                                          G_TYPE_DOUBLE, high_input,
+                                          G_TYPE_BOOLEAN, clamp_input,
+                                          G_TYPE_DOUBLE, gamma,
+                                          G_TYPE_DOUBLE, low_output,
+                                          G_TYPE_DOUBLE, high_output,
+                                          G_TYPE_BOOLEAN, clamp_output,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-levels",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-levels",
+                                            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_drawable_levels: (skip)
  * @drawable_ID: The drawable.
  * @channel: The channel to modify.
  * @low_input: Intensity of lowest input.
@@ -632,15 +1272,15 @@ gimp_drawable_invert (gint32   drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_levels (gint32               drawable_ID,
-                      GimpHistogramChannel channel,
-                      gdouble              low_input,
-                      gdouble              high_input,
-                      gboolean             clamp_input,
-                      gdouble              gamma,
-                      gdouble              low_output,
-                      gdouble              high_output,
-                      gboolean             clamp_output)
+_gimp_drawable_levels (gint32               drawable_ID,
+                       GimpHistogramChannel channel,
+                       gdouble              low_input,
+                       gdouble              high_input,
+                       gboolean             clamp_input,
+                       gdouble              gamma,
+                       gdouble              low_output,
+                       gdouble              high_output,
+                       gboolean             clamp_output)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -677,6 +1317,48 @@ gimp_drawable_levels (gint32               drawable_ID,
 
 /**
  * gimp_drawable_levels_stretch:
+ * @drawable: The drawable.
+ *
+ * Automatically modifies intensity levels in the specified drawable.
+ *
+ * This procedure allows intensity levels in the specified drawable to
+ * be remapped according to a set of guessed parameters. It is
+ * equivalent to clicking the \"Auto\" button in the Levels tool.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_levels_stretch (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-levels-stretch",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-levels-stretch",
+                                            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_drawable_levels_stretch: (skip)
  * @drawable_ID: The drawable.
  *
  * Automatically modifies intensity levels in the specified drawable.
@@ -690,7 +1372,7 @@ gimp_drawable_levels (gint32               drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_levels_stretch (gint32 drawable_ID)
+_gimp_drawable_levels_stretch (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -719,6 +1401,50 @@ gimp_drawable_levels_stretch (gint32 drawable_ID)
 
 /**
  * gimp_drawable_posterize:
+ * @drawable: The drawable.
+ * @levels: Levels of posterization.
+ *
+ * Posterize the specified drawable.
+ *
+ * This procedures reduces the number of shades allows in each
+ * intensity channel to the specified 'levels' parameter.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_posterize (GimpDrawable *drawable,
+                         gint          levels)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, levels,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-posterize",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-posterize",
+                                            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_drawable_posterize: (skip)
  * @drawable_ID: The drawable.
  * @levels: Levels of posterization.
  *
@@ -732,8 +1458,8 @@ gimp_drawable_levels_stretch (gint32 drawable_ID)
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_posterize (gint32 drawable_ID,
-                         gint   levels)
+_gimp_drawable_posterize (gint32 drawable_ID,
+                          gint   levels)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -763,6 +1489,58 @@ gimp_drawable_posterize (gint32 drawable_ID,
 
 /**
  * gimp_drawable_threshold:
+ * @drawable: The drawable.
+ * @channel: The channel to base the threshold on.
+ * @low_threshold: The low threshold value.
+ * @high_threshold: The high threshold value.
+ *
+ * Threshold the specified drawable.
+ *
+ * This procedures generates a threshold map of the specified drawable.
+ * All pixels between the values of 'low_threshold' and
+ * 'high_threshold', on the scale of 'channel' are replaced with white,
+ * and all other pixels with black.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_threshold (GimpDrawable         *drawable,
+                         GimpHistogramChannel  channel,
+                         gdouble               low_threshold,
+                         gdouble               high_threshold)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, low_threshold,
+                                          G_TYPE_DOUBLE, high_threshold,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-threshold",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-threshold",
+                                            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_drawable_threshold: (skip)
  * @drawable_ID: The drawable.
  * @channel: The channel to base the threshold on.
  * @low_threshold: The low threshold value.
@@ -780,10 +1558,10 @@ gimp_drawable_posterize (gint32 drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_threshold (gint32               drawable_ID,
-                         GimpHistogramChannel channel,
-                         gdouble              low_threshold,
-                         gdouble              high_threshold)
+_gimp_drawable_threshold (gint32               drawable_ID,
+                          GimpHistogramChannel channel,
+                          gdouble              low_threshold,
+                          gdouble              high_threshold)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpdrawablecolor_pdb.h b/libgimp/gimpdrawablecolor_pdb.h
index 3a7be30253..c5fdacc834 100644
--- a/libgimp/gimpdrawablecolor_pdb.h
+++ b/libgimp/gimpdrawablecolor_pdb.h
@@ -32,32 +32,36 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_drawable_brightness_contrast (gint32                drawable_ID,
+
+
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
+
+gboolean gimp_drawable_brightness_contrast (GimpDrawable         *drawable,
                                             gdouble               brightness,
                                             gdouble               contrast);
-gboolean gimp_drawable_color_balance       (gint32                drawable_ID,
+gboolean gimp_drawable_color_balance       (GimpDrawable         *drawable,
                                             GimpTransferMode      transfer_mode,
                                             gboolean              preserve_lum,
                                             gdouble               cyan_red,
                                             gdouble               magenta_green,
                                             gdouble               yellow_blue);
-gboolean gimp_drawable_colorize_hsl        (gint32                drawable_ID,
+gboolean gimp_drawable_colorize_hsl        (GimpDrawable         *drawable,
                                             gdouble               hue,
                                             gdouble               saturation,
                                             gdouble               lightness);
-gboolean gimp_drawable_curves_explicit     (gint32                drawable_ID,
+gboolean gimp_drawable_curves_explicit     (GimpDrawable         *drawable,
                                             GimpHistogramChannel  channel,
                                             gint                  num_values,
                                             const gdouble        *values);
-gboolean gimp_drawable_curves_spline       (gint32                drawable_ID,
+gboolean gimp_drawable_curves_spline       (GimpDrawable         *drawable,
                                             GimpHistogramChannel  channel,
                                             gint                  num_points,
                                             const gdouble        *points);
-gboolean gimp_drawable_desaturate          (gint32                drawable_ID,
+gboolean gimp_drawable_desaturate          (GimpDrawable         *drawable,
                                             GimpDesaturateMode    desaturate_mode);
-gboolean gimp_drawable_equalize            (gint32                drawable_ID,
+gboolean gimp_drawable_equalize            (GimpDrawable         *drawable,
                                             gboolean              mask_only);
-gboolean gimp_drawable_histogram           (gint32                drawable_ID,
+gboolean gimp_drawable_histogram           (GimpDrawable         *drawable,
                                             GimpHistogramChannel  channel,
                                             gdouble               start_range,
                                             gdouble               end_range,
@@ -67,15 +71,15 @@ gboolean gimp_drawable_histogram           (gint32                drawable_ID,
                                             gdouble              *pixels,
                                             gdouble              *count,
                                             gdouble              *percentile);
-gboolean gimp_drawable_hue_saturation      (gint32                drawable_ID,
+gboolean gimp_drawable_hue_saturation      (GimpDrawable         *drawable,
                                             GimpHueRange          hue_range,
                                             gdouble               hue_offset,
                                             gdouble               lightness,
                                             gdouble               saturation,
                                             gdouble               overlap);
-gboolean gimp_drawable_invert              (gint32                drawable_ID,
+gboolean gimp_drawable_invert              (GimpDrawable         *drawable,
                                             gboolean              linear);
-gboolean gimp_drawable_levels              (gint32                drawable_ID,
+gboolean gimp_drawable_levels              (GimpDrawable         *drawable,
                                             GimpHistogramChannel  channel,
                                             gdouble               low_input,
                                             gdouble               high_input,
@@ -84,20 +88,30 @@ gboolean gimp_drawable_levels              (gint32                drawable_ID,
                                             gdouble               low_output,
                                             gdouble               high_output,
                                             gboolean              clamp_output);
-gboolean gimp_drawable_levels_stretch      (gint32                drawable_ID);
-gboolean gimp_drawable_posterize           (gint32                drawable_ID,
+gboolean gimp_drawable_levels_stretch      (GimpDrawable         *drawable);
+gboolean gimp_drawable_posterize           (GimpDrawable         *drawable,
                                             gint                  levels);
-gboolean gimp_drawable_threshold           (gint32                drawable_ID,
+gboolean gimp_drawable_threshold           (GimpDrawable         *drawable,
                                             GimpHistogramChannel  channel,
                                             gdouble               low_threshold,
                                             gdouble               high_threshold);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
-
-
-
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_drawable_brightness_contrast _gimp_drawable_brightness_contrast
+#define gimp_drawable_color_balance _gimp_drawable_color_balance
+#define gimp_drawable_colorize_hsl _gimp_drawable_colorize_hsl
+#define gimp_drawable_curves_explicit _gimp_drawable_curves_explicit
+#define gimp_drawable_curves_spline _gimp_drawable_curves_spline
+#define gimp_drawable_desaturate _gimp_drawable_desaturate
+#define gimp_drawable_equalize _gimp_drawable_equalize
+#define gimp_drawable_histogram _gimp_drawable_histogram
+#define gimp_drawable_hue_saturation _gimp_drawable_hue_saturation
+#define gimp_drawable_invert _gimp_drawable_invert
+#define gimp_drawable_levels _gimp_drawable_levels
+#define gimp_drawable_levels_stretch _gimp_drawable_levels_stretch
+#define gimp_drawable_posterize _gimp_drawable_posterize
+#define gimp_drawable_threshold _gimp_drawable_threshold
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -106,7 +120,65 @@ gboolean gimp_drawable_threshold           (gint32                drawable_ID,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gboolean _gimp_drawable_brightness_contrast (gint32                drawable_ID,
+                                             gdouble               brightness,
+                                             gdouble               contrast);
+gboolean _gimp_drawable_color_balance       (gint32                drawable_ID,
+                                             GimpTransferMode      transfer_mode,
+                                             gboolean              preserve_lum,
+                                             gdouble               cyan_red,
+                                             gdouble               magenta_green,
+                                             gdouble               yellow_blue);
+gboolean _gimp_drawable_colorize_hsl        (gint32                drawable_ID,
+                                             gdouble               hue,
+                                             gdouble               saturation,
+                                             gdouble               lightness);
+gboolean _gimp_drawable_curves_explicit     (gint32                drawable_ID,
+                                             GimpHistogramChannel  channel,
+                                             gint                  num_values,
+                                             const gdouble        *values);
+gboolean _gimp_drawable_curves_spline       (gint32                drawable_ID,
+                                             GimpHistogramChannel  channel,
+                                             gint                  num_points,
+                                             const gdouble        *points);
+gboolean _gimp_drawable_desaturate          (gint32                drawable_ID,
+                                             GimpDesaturateMode    desaturate_mode);
+gboolean _gimp_drawable_equalize            (gint32                drawable_ID,
+                                             gboolean              mask_only);
+gboolean _gimp_drawable_histogram           (gint32                drawable_ID,
+                                             GimpHistogramChannel  channel,
+                                             gdouble               start_range,
+                                             gdouble               end_range,
+                                             gdouble              *mean,
+                                             gdouble              *std_dev,
+                                             gdouble              *median,
+                                             gdouble              *pixels,
+                                             gdouble              *count,
+                                             gdouble              *percentile);
+gboolean _gimp_drawable_hue_saturation      (gint32                drawable_ID,
+                                             GimpHueRange          hue_range,
+                                             gdouble               hue_offset,
+                                             gdouble               lightness,
+                                             gdouble               saturation,
+                                             gdouble               overlap);
+gboolean _gimp_drawable_invert              (gint32                drawable_ID,
+                                             gboolean              linear);
+gboolean _gimp_drawable_levels              (gint32                drawable_ID,
+                                             GimpHistogramChannel  channel,
+                                             gdouble               low_input,
+                                             gdouble               high_input,
+                                             gboolean              clamp_input,
+                                             gdouble               gamma,
+                                             gdouble               low_output,
+                                             gdouble               high_output,
+                                             gboolean              clamp_output);
+gboolean _gimp_drawable_levels_stretch      (gint32                drawable_ID);
+gboolean _gimp_drawable_posterize           (gint32                drawable_ID,
+                                             gint                  levels);
+gboolean _gimp_drawable_threshold           (gint32                drawable_ID,
+                                             GimpHistogramChannel  channel,
+                                             gdouble               low_threshold,
+                                             gdouble               high_threshold);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c
index 8ca9fe6cf7..b570bbbd21 100644
--- a/libgimp/gimpdrawableedit_pdb.c
+++ b/libgimp/gimpdrawableedit_pdb.c
@@ -36,6 +36,51 @@
 
 /**
  * gimp_drawable_edit_clear:
+ * @drawable: The drawable to clear from.
+ *
+ * Clear selected area of drawable.
+ *
+ * This procedure clears the specified drawable. If the drawable has an
+ * alpha channel, the cleared pixels will become transparent. If the
+ * drawable does not have an alpha channel, cleared pixels will be set
+ * to the background color. This procedure only affects regions within
+ * a selection if there is a selection active.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_background().
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_edit_clear (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-clear",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-clear",
+                                            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_drawable_edit_clear: (skip)
  * @drawable_ID: The drawable to clear from.
  *
  * Clear selected area of drawable.
@@ -52,7 +97,7 @@
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_edit_clear (gint32 drawable_ID)
+_gimp_drawable_edit_clear (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -81,6 +126,55 @@ gimp_drawable_edit_clear (gint32 drawable_ID)
 
 /**
  * gimp_drawable_edit_fill:
+ * @drawable: The drawable to fill to.
+ * @fill_type: The type of fill.
+ *
+ * Fill selected area of drawable.
+ *
+ * This procedure fills the specified drawable according to fill mode.
+ * This procedure only affects regions within a selection if there is a
+ * selection active. If you want to fill the whole drawable, regardless
+ * of the selection, use gimp_drawable_fill().
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_opacity(), gimp_context_set_paint_mode(),
+ * gimp_context_set_foreground(), gimp_context_set_background(),
+ * gimp_context_set_pattern().
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_edit_fill (GimpDrawable *drawable,
+                         GimpFillType  fill_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-fill",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-fill",
+                                            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_drawable_edit_fill: (skip)
  * @drawable_ID: The drawable to fill to.
  * @fill_type: The type of fill.
  *
@@ -99,8 +193,8 @@ gimp_drawable_edit_clear (gint32 drawable_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_edit_fill (gint32       drawable_ID,
-                         GimpFillType fill_type)
+_gimp_drawable_edit_fill (gint32       drawable_ID,
+                          GimpFillType fill_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -130,6 +224,67 @@ gimp_drawable_edit_fill (gint32       drawable_ID,
 
 /**
  * gimp_drawable_edit_bucket_fill:
+ * @drawable: The affected drawable.
+ * @fill_type: The type of fill.
+ * @x: The x coordinate of this bucket fill's application.
+ * @y: The y coordinate of this bucket fill's application.
+ *
+ * Fill the area by a seed fill starting at the specified coordinates.
+ *
+ * This procedure does a seed fill at the specified coordinates, using
+ * various parameters from the current context.
+ * In the case of merged sampling, the x and y coordinates are relative
+ * to the image's origin; otherwise, they are relative to the
+ * drawable's origin.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_opacity(), gimp_context_set_paint_mode(),
+ * gimp_context_set_foreground(), gimp_context_set_background(),
+ * gimp_context_set_pattern(), gimp_context_set_sample_threshold(),
+ * gimp_context_set_sample_merged(),
+ * gimp_context_set_sample_criterion(),
+ * gimp_context_set_diagonal_neighbors(), gimp_context_set_antialias().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_edit_bucket_fill (GimpDrawable *drawable,
+                                GimpFillType  fill_type,
+                                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_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-bucket-fill",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-bucket-fill",
+                                            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_drawable_edit_bucket_fill: (skip)
  * @drawable_ID: The affected drawable.
  * @fill_type: The type of fill.
  * @x: The x coordinate of this bucket fill's application.
@@ -156,10 +311,10 @@ gimp_drawable_edit_fill (gint32       drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_edit_bucket_fill (gint32       drawable_ID,
-                                GimpFillType fill_type,
-                                gdouble      x,
-                                gdouble      y)
+_gimp_drawable_edit_bucket_fill (gint32       drawable_ID,
+                                 GimpFillType fill_type,
+                                 gdouble      x,
+                                 gdouble      y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -191,6 +346,87 @@ gimp_drawable_edit_bucket_fill (gint32       drawable_ID,
 
 /**
  * gimp_drawable_edit_gradient_fill:
+ * @drawable: The affected drawable.
+ * @gradient_type: The type of gradient.
+ * @offset: Offset relates to the starting and ending coordinates specified for the blend. This parameter is 
mode dependent.
+ * @supersample: Do adaptive supersampling.
+ * @supersample_max_depth: Maximum recursion levels for supersampling.
+ * @supersample_threshold: Supersampling threshold.
+ * @dither: Use dithering to reduce banding.
+ * @x1: The x coordinate of this gradient's starting point.
+ * @y1: The y coordinate of this gradient's starting point.
+ * @x2: The x coordinate of this gradient's ending point.
+ * @y2: The y coordinate of this gradient's ending point.
+ *
+ * Draw a gradient between the starting and ending coordinates with the
+ * specified gradient type.
+ *
+ * This tool requires information on the gradient type. It creates the
+ * specified variety of gradient using the starting and ending
+ * coordinates as defined for each gradient type. For shapeburst
+ * gradient types, the context's distance metric is also relevant and
+ * can be updated with gimp_context_set_distance_metric().
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_opacity(), gimp_context_set_paint_mode(),
+ * gimp_context_set_foreground(), gimp_context_set_background(),
+ * gimp_context_set_gradient() and all gradient property settings,
+ * gimp_context_set_distance_metric().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_edit_gradient_fill (GimpDrawable     *drawable,
+                                  GimpGradientType  gradient_type,
+                                  gdouble           offset,
+                                  gboolean          supersample,
+                                  gint              supersample_max_depth,
+                                  gdouble           supersample_threshold,
+                                  gboolean          dither,
+                                  gdouble           x1,
+                                  gdouble           y1,
+                                  gdouble           x2,
+                                  gdouble           y2)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_GRADIENT_TYPE, gradient_type,
+                                          G_TYPE_DOUBLE, offset,
+                                          G_TYPE_BOOLEAN, supersample,
+                                          G_TYPE_INT, supersample_max_depth,
+                                          G_TYPE_DOUBLE, supersample_threshold,
+                                          G_TYPE_BOOLEAN, dither,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-gradient-fill",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-gradient-fill",
+                                            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_drawable_edit_gradient_fill: (skip)
  * @drawable_ID: The affected drawable.
  * @gradient_type: The type of gradient.
  * @offset: Offset relates to the starting and ending coordinates specified for the blend. This parameter is 
mode dependent.
@@ -223,17 +459,17 @@ gimp_drawable_edit_bucket_fill (gint32       drawable_ID,
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_edit_gradient_fill (gint32           drawable_ID,
-                                  GimpGradientType gradient_type,
-                                  gdouble          offset,
-                                  gboolean         supersample,
-                                  gint             supersample_max_depth,
-                                  gdouble          supersample_threshold,
-                                  gboolean         dither,
-                                  gdouble          x1,
-                                  gdouble          y1,
-                                  gdouble          x2,
-                                  gdouble          y2)
+_gimp_drawable_edit_gradient_fill (gint32           drawable_ID,
+                                   GimpGradientType gradient_type,
+                                   gdouble          offset,
+                                   gboolean         supersample,
+                                   gint             supersample_max_depth,
+                                   gdouble          supersample_threshold,
+                                   gboolean         dither,
+                                   gdouble          x1,
+                                   gdouble          y1,
+                                   gdouble          x2,
+                                   gdouble          y2)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -272,6 +508,55 @@ gimp_drawable_edit_gradient_fill (gint32           drawable_ID,
 
 /**
  * gimp_drawable_edit_stroke_selection:
+ * @drawable: The drawable to stroke to.
+ *
+ * Stroke the current selection
+ *
+ * This procedure strokes the current selection, painting along the
+ * selection boundary with the active paint method and brush, or using
+ * a plain line with configurable properties. The paint is applied to
+ * the specified drawable regardless of the active selection.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_opacity(), gimp_context_set_paint_mode(),
+ * gimp_context_set_paint_method(), gimp_context_set_stroke_method(),
+ * gimp_context_set_foreground(), gimp_context_set_brush() and all
+ * brush property settings, gimp_context_set_gradient() and all
+ * gradient property settings, gimp_context_set_line_width() and all
+ * line property settings, gimp_context_set_antialias().
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_drawable_edit_stroke_selection (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-stroke-selection",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-selection",
+                                            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_drawable_edit_stroke_selection: (skip)
  * @drawable_ID: The drawable to stroke to.
  *
  * Stroke the current selection
@@ -292,7 +577,7 @@ gimp_drawable_edit_gradient_fill (gint32           drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
+_gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -321,6 +606,60 @@ gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
 
 /**
  * gimp_drawable_edit_stroke_item:
+ * @drawable: The drawable to stroke to.
+ * @item: The item to stroke.
+ *
+ * Stroke the specified item
+ *
+ * This procedure strokes the specified item, painting along its
+ * outline (e.g. along a path, or along a channel's boundary), with the
+ * active paint method and brush, or using a plain line with
+ * configurable properties.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_opacity(), gimp_context_set_paint_mode(),
+ * gimp_context_set_paint_method(), gimp_context_set_stroke_method(),
+ * gimp_context_set_foreground(), gimp_context_set_brush() and all
+ * brush property settings, gimp_context_set_gradient() and all
+ * gradient property settings, gimp_context_set_line_width() and all
+ * line property settings, gimp_context_set_antialias().
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_drawable_edit_stroke_item (GimpDrawable *drawable,
+                                GimpItem     *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-drawable-edit-stroke-item",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-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;
+}
+
+/**
+ * _gimp_drawable_edit_stroke_item: (skip)
  * @drawable_ID: The drawable to stroke to.
  * @item_ID: The item to stroke.
  *
@@ -344,8 +683,8 @@ gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
  * Since: 2.10
  **/
 gboolean
-gimp_drawable_edit_stroke_item (gint32 drawable_ID,
-                                gint32 item_ID)
+_gimp_drawable_edit_stroke_item (gint32 drawable_ID,
+                                 gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpdrawableedit_pdb.h b/libgimp/gimpdrawableedit_pdb.h
index d3f23aa42f..8eec9ef43d 100644
--- a/libgimp/gimpdrawableedit_pdb.h
+++ b/libgimp/gimpdrawableedit_pdb.h
@@ -32,34 +32,40 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_drawable_edit_clear            (gint32           drawable_ID);
-gboolean gimp_drawable_edit_fill             (gint32           drawable_ID,
-                                              GimpFillType     fill_type);
-gboolean gimp_drawable_edit_bucket_fill      (gint32           drawable_ID,
-                                              GimpFillType     fill_type,
-                                              gdouble          x,
-                                              gdouble          y);
-gboolean gimp_drawable_edit_gradient_fill    (gint32           drawable_ID,
-                                              GimpGradientType gradient_type,
-                                              gdouble          offset,
-                                              gboolean         supersample,
-                                              gint             supersample_max_depth,
-                                              gdouble          supersample_threshold,
-                                              gboolean         dither,
-                                              gdouble          x1,
-                                              gdouble          y1,
-                                              gdouble          x2,
-                                              gdouble          y2);
-gboolean gimp_drawable_edit_stroke_selection (gint32           drawable_ID);
-gboolean gimp_drawable_edit_stroke_item      (gint32           drawable_ID,
-                                              gint32           item_ID);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+gboolean gimp_drawable_edit_clear            (GimpDrawable     *drawable);
+gboolean gimp_drawable_edit_fill             (GimpDrawable     *drawable,
+                                              GimpFillType      fill_type);
+gboolean gimp_drawable_edit_bucket_fill      (GimpDrawable     *drawable,
+                                              GimpFillType      fill_type,
+                                              gdouble           x,
+                                              gdouble           y);
+gboolean gimp_drawable_edit_gradient_fill    (GimpDrawable     *drawable,
+                                              GimpGradientType  gradient_type,
+                                              gdouble           offset,
+                                              gboolean          supersample,
+                                              gint              supersample_max_depth,
+                                              gdouble           supersample_threshold,
+                                              gboolean          dither,
+                                              gdouble           x1,
+                                              gdouble           y1,
+                                              gdouble           x2,
+                                              gdouble           y2);
+gboolean gimp_drawable_edit_stroke_selection (GimpDrawable     *drawable);
+gboolean gimp_drawable_edit_stroke_item      (GimpDrawable     *drawable,
+                                              GimpItem         *item);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_drawable_edit_clear _gimp_drawable_edit_clear
+#define gimp_drawable_edit_fill _gimp_drawable_edit_fill
+#define gimp_drawable_edit_bucket_fill _gimp_drawable_edit_bucket_fill
+#define gimp_drawable_edit_gradient_fill _gimp_drawable_edit_gradient_fill
+#define gimp_drawable_edit_stroke_selection _gimp_drawable_edit_stroke_selection
+#define gimp_drawable_edit_stroke_item _gimp_drawable_edit_stroke_item
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -68,7 +74,27 @@ gboolean gimp_drawable_edit_stroke_item      (gint32           drawable_ID,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gboolean _gimp_drawable_edit_clear            (gint32           drawable_ID);
+gboolean _gimp_drawable_edit_fill             (gint32           drawable_ID,
+                                               GimpFillType     fill_type);
+gboolean _gimp_drawable_edit_bucket_fill      (gint32           drawable_ID,
+                                               GimpFillType     fill_type,
+                                               gdouble          x,
+                                               gdouble          y);
+gboolean _gimp_drawable_edit_gradient_fill    (gint32           drawable_ID,
+                                               GimpGradientType gradient_type,
+                                               gdouble          offset,
+                                               gboolean         supersample,
+                                               gint             supersample_max_depth,
+                                               gdouble          supersample_threshold,
+                                               gboolean         dither,
+                                               gdouble          x1,
+                                               gdouble          y1,
+                                               gdouble          x2,
+                                               gdouble          y2);
+gboolean _gimp_drawable_edit_stroke_selection (gint32           drawable_ID);
+gboolean _gimp_drawable_edit_stroke_item      (gint32           drawable_ID,
+                                               gint32           item_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index 4d459445e1..db17527177 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -36,6 +36,52 @@
 
 /**
  * gimp_edit_cut:
+ * @drawable: The drawable to cut from.
+ *
+ * Cut from the specified drawable.
+ *
+ * If there is a selection in the image, then the area specified by the
+ * selection is cut from the specified drawable 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
+ * specified drawable will be removed and its contents stored in the
+ * internal GIMP edit buffer. This procedure will fail if the selected
+ * area lies completely outside the bounds of the current drawable and
+ * there is nothing to copy from.
+ *
+ * Returns: TRUE if the cut was successful, FALSE if there was nothing to copy from.
+ **/
+gboolean
+gimp_edit_cut (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-cut",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-cut",
+                                            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_cut: (skip)
  * @drawable_ID: The drawable to cut from.
  *
  * Cut from the specified drawable.
@@ -52,7 +98,7 @@
  * Returns: TRUE if the cut was successful, FALSE if there was nothing to copy from.
  **/
 gboolean
-gimp_edit_cut (gint32 drawable_ID)
+_gimp_edit_cut (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -82,6 +128,52 @@ gimp_edit_cut (gint32 drawable_ID)
 
 /**
  * gimp_edit_copy:
+ * @drawable: The drawable to copy from.
+ *
+ * Copy from the specified drawable.
+ *
+ * If there is a selection in the image, then the area specified by the
+ * selection is copied from the specified drawable 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
+ * specified drawable's contents will be stored in the internal GIMP
+ * edit buffer. This procedure will fail if the selected area lies
+ * completely outside the bounds of the current drawable and there is
+ * nothing to copy from.
+ *
+ * Returns: TRUE if the cut was successful, FALSE if there was nothing to copy from.
+ **/
+gboolean
+gimp_edit_copy (GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean non_empty = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-copy",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-copy",
+                                            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_copy: (skip)
  * @drawable_ID: The drawable to copy from.
  *
  * Copy from the specified drawable.
@@ -98,7 +190,7 @@ gimp_edit_cut (gint32 drawable_ID)
  * Returns: TRUE if the cut was successful, FALSE if there was nothing to copy from.
  **/
 gboolean
-gimp_edit_copy (gint32 drawable_ID)
+_gimp_edit_copy (gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -220,6 +312,62 @@ _gimp_edit_copy_visible (gint32 image_ID)
 
 /**
  * gimp_edit_paste:
+ * @drawable: The drawable to paste to.
+ * @paste_into: Clear selection, or paste behind it?
+ *
+ * Paste buffer to the specified drawable.
+ *
+ * This procedure pastes a copy of the internal GIMP edit buffer to the
+ * specified drawable. The GIMP edit buffer will be empty unless a call
+ * was previously made to either gimp_edit_cut() or gimp_edit_copy().
+ * The \"paste_into\" option specifies whether to clear the current
+ * image selection, or to paste the buffer \"behind\" the selection.
+ * This allows the selection to act as a mask for the pasted buffer.
+ * Anywhere that the selection mask is non-zero, the pasted buffer will
+ * show through. The pasted buffer will be a new layer in the image
+ * which is designated as the image floating selection. If the image
+ * has a floating selection at the time of pasting, the old floating
+ * selection will be anchored to its drawable before the new floating
+ * selection is added. This procedure returns the new floating layer.
+ * The resulting floating selection will already be attached to the
+ * specified drawable, and a subsequent call to floating_sel_attach is
+ * not needed.
+ *
+ * Returns: (transfer full): The new floating selection.
+ **/
+GimpLayer *
+gimp_edit_paste (GimpDrawable *drawable,
+                 gboolean      paste_into)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayer *floating_sel = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_BOOLEAN, paste_into,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-paste",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-paste",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    floating_sel = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
+
+  gimp_value_array_unref (return_vals);
+
+  return floating_sel;
+}
+
+/**
+ * _gimp_edit_paste: (skip)
  * @drawable_ID: The drawable to paste to.
  * @paste_into: Clear selection, or paste behind it?
  *
@@ -244,8 +392,8 @@ _gimp_edit_copy_visible (gint32 image_ID)
  * Returns: The new floating selection.
  **/
 gint32
-gimp_edit_paste (gint32   drawable_ID,
-                 gboolean paste_into)
+_gimp_edit_paste (gint32   drawable_ID,
+                  gboolean paste_into)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -360,7 +508,7 @@ _gimp_edit_paste_as_new_image (void)
 
 /**
  * gimp_edit_named_cut:
- * @drawable_ID: The drawable to cut from.
+ * @drawable: The drawable to cut from.
  * @buffer_name: The name of the buffer to create.
  *
  * Cut into a named buffer.
@@ -377,8 +525,56 @@ _gimp_edit_paste_as_new_image (void)
  * Since: 2.4
  **/
 gchar *
-gimp_edit_named_cut (gint32       drawable_ID,
-                     const gchar *buffer_name)
+gimp_edit_named_cut (GimpDrawable *drawable,
+                     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_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-named-cut",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-named-cut",
+                                            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_cut: (skip)
+ * @drawable_ID: The drawable to cut from.
+ * @buffer_name: The name of the buffer to create.
+ *
+ * Cut into a named buffer.
+ *
+ * This procedure works like gimp_edit_cut(), but additionally stores
+ * the cut 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 cut failed.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.4
+ **/
+gchar *
+_gimp_edit_named_cut (gint32       drawable_ID,
+                      const gchar *buffer_name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -409,7 +605,7 @@ gimp_edit_named_cut (gint32       drawable_ID,
 
 /**
  * gimp_edit_named_copy:
- * @drawable_ID: The drawable to copy from.
+ * @drawable: The drawable to copy from.
  * @buffer_name: The name of the buffer to create.
  *
  * Copy into a named buffer.
@@ -426,8 +622,56 @@ gimp_edit_named_cut (gint32       drawable_ID,
  * Since: 2.4
  **/
 gchar *
-gimp_edit_named_copy (gint32       drawable_ID,
-                      const gchar *buffer_name)
+gimp_edit_named_copy (GimpDrawable *drawable,
+                      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_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-named-copy",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-named-copy",
+                                            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_copy: (skip)
+ * @drawable_ID: The drawable to copy from.
+ * @buffer_name: The name of the buffer to create.
+ *
+ * Copy into a named buffer.
+ *
+ * This procedure works like gimp_edit_copy(), 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 (gint32       drawable_ID,
+                       const gchar *buffer_name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -555,6 +799,54 @@ _gimp_edit_named_copy_visible (gint32       image_ID,
 
 /**
  * gimp_edit_named_paste:
+ * @drawable: The drawable to paste to.
+ * @buffer_name: The name of the buffer to paste.
+ * @paste_into: Clear selection, or paste behind it?
+ *
+ * Paste named buffer to the specified drawable.
+ *
+ * This procedure works like gimp_edit_paste() but pastes a named
+ * buffer instead of the global buffer.
+ *
+ * Returns: (transfer full): The new floating selection.
+ *
+ * Since: 2.4
+ **/
+GimpLayer *
+gimp_edit_named_paste (GimpDrawable *drawable,
+                       const gchar  *buffer_name,
+                       gboolean      paste_into)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayer *floating_sel = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_BOOLEAN, paste_into,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-edit-named-paste",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-edit-named-paste",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    floating_sel = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
+
+  gimp_value_array_unref (return_vals);
+
+  return floating_sel;
+}
+
+/**
+ * _gimp_edit_named_paste: (skip)
  * @drawable_ID: The drawable to paste to.
  * @buffer_name: The name of the buffer to paste.
  * @paste_into: Clear selection, or paste behind it?
@@ -569,9 +861,9 @@ _gimp_edit_named_copy_visible (gint32       image_ID,
  * Since: 2.4
  **/
 gint32
-gimp_edit_named_paste (gint32       drawable_ID,
-                       const gchar *buffer_name,
-                       gboolean     paste_into)
+_gimp_edit_named_paste (gint32       drawable_ID,
+                        const gchar *buffer_name,
+                        gboolean     paste_into)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpedit_pdb.h b/libgimp/gimpedit_pdb.h
index de5cfab9b7..2326b01136 100644
--- a/libgimp/gimpedit_pdb.h
+++ b/libgimp/gimpedit_pdb.h
@@ -32,31 +32,38 @@ 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);
-gint32   gimp_edit_paste       (gint32       drawable_ID,
-                                gboolean     paste_into);
-gchar*   gimp_edit_named_cut   (gint32       drawable_ID,
-                                const gchar *buffer_name);
-gchar*   gimp_edit_named_copy  (gint32       drawable_ID,
-                                const gchar *buffer_name);
-gint32   gimp_edit_named_paste (gint32       drawable_ID,
-                                const gchar *buffer_name,
-                                gboolean     paste_into);
+
 
 #ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
-gboolean   gimp_edit_copy_visible             (GimpImage   *image);
+gboolean   gimp_edit_cut                      (GimpDrawable *drawable);
+gboolean   gimp_edit_copy                     (GimpDrawable *drawable);
+gboolean   gimp_edit_copy_visible             (GimpImage    *image);
+GimpLayer* gimp_edit_paste                    (GimpDrawable *drawable,
+                                               gboolean      paste_into);
 GimpImage* gimp_edit_paste_as_new_image       (void);
-gchar*     gimp_edit_named_copy_visible       (GimpImage   *image,
-                                               const gchar *buffer_name);
-GimpImage* gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
+gchar*     gimp_edit_named_cut                (GimpDrawable *drawable,
+                                               const gchar  *buffer_name);
+gchar*     gimp_edit_named_copy               (GimpDrawable *drawable,
+                                               const gchar  *buffer_name);
+gchar*     gimp_edit_named_copy_visible       (GimpImage    *image,
+                                               const gchar  *buffer_name);
+GimpLayer* gimp_edit_named_paste              (GimpDrawable *drawable,
+                                               const gchar  *buffer_name,
+                                               gboolean      paste_into);
+GimpImage* gimp_edit_named_paste_as_new_image (const gchar  *buffer_name);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_edit_cut _gimp_edit_cut
+#define gimp_edit_copy _gimp_edit_copy
 #define gimp_edit_copy_visible _gimp_edit_copy_visible
+#define gimp_edit_paste _gimp_edit_paste
 #define gimp_edit_paste_as_new_image _gimp_edit_paste_as_new_image
+#define gimp_edit_named_cut _gimp_edit_named_cut
+#define gimp_edit_named_copy _gimp_edit_named_copy
 #define gimp_edit_named_copy_visible _gimp_edit_named_copy_visible
+#define gimp_edit_named_paste _gimp_edit_named_paste
 #define gimp_edit_named_paste_as_new_image _gimp_edit_named_paste_as_new_image
 
 
@@ -66,10 +73,21 @@ GimpImage* gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
+gboolean _gimp_edit_cut                      (gint32       drawable_ID);
+gboolean _gimp_edit_copy                     (gint32       drawable_ID);
 gboolean _gimp_edit_copy_visible             (gint32       image_ID);
+gint32   _gimp_edit_paste                    (gint32       drawable_ID,
+                                              gboolean     paste_into);
 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       (gint32       image_ID,
                                               const gchar *buffer_name);
+gint32   _gimp_edit_named_paste              (gint32       drawable_ID,
+                                              const gchar *buffer_name,
+                                              gboolean     paste_into);
 gint32   _gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
 
 
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index 794da05541..7ae4f8b035 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -149,11 +149,11 @@ _gimp_file_load (GimpRunMode  run_mode,
  * needs to be added to the existing image with
  * gimp_image_insert_layer().
  *
- * Returns: The layer created when loading the image file.
+ * Returns: (transfer full): The layer created when loading the image file.
  *
  * Since: 2.4
  **/
-gint32
+GimpLayer *
 gimp_file_load_layer (GimpRunMode  run_mode,
                       GimpImage   *image,
                       const gchar *filename)
@@ -161,7 +161,7 @@ gimp_file_load_layer (GimpRunMode  run_mode,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_RUN_MODE, run_mode,
@@ -179,11 +179,11 @@ gimp_file_load_layer (GimpRunMode  run_mode,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -357,7 +357,7 @@ _gimp_file_load_layers (GimpRunMode  run_mode,
  * gimp_file_save:
  * @run_mode: The run mode.
  * @image: Input image.
- * @drawable_ID: Drawable to save.
+ * @drawable: Drawable to save.
  * @filename: The name of the file to save the image in.
  * @raw_filename: The name as entered by the user.
  *
@@ -374,11 +374,11 @@ _gimp_file_load_layers (GimpRunMode  run_mode,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_file_save (GimpRunMode  run_mode,
-                GimpImage   *image,
-                gint32       drawable_ID,
-                const gchar *filename,
-                const gchar *raw_filename)
+gimp_file_save (GimpRunMode   run_mode,
+                GimpImage    *image,
+                GimpDrawable *drawable,
+                const gchar  *filename,
+                const gchar  *raw_filename)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -388,7 +388,7 @@ gimp_file_save (GimpRunMode  run_mode,
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_RUN_MODE, run_mode,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_STRING, filename,
                                           G_TYPE_STRING, raw_filename,
                                           G_TYPE_NONE);
diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h
index 811e92f51d..4574c7cb66 100644
--- a/libgimp/gimpfileops_pdb.h
+++ b/libgimp/gimpfileops_pdb.h
@@ -53,23 +53,23 @@ G_GNUC_INTERNAL gboolean _gimp_register_thumbnail_loader      (const gchar *load
 
 #ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
-GimpImage* 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);
-gint*      gimp_file_load_layers    (GimpRunMode  run_mode,
-                                     GimpImage   *image,
-                                     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);
-gboolean   gimp_file_save_thumbnail (GimpImage   *image,
-                                     const gchar *filename);
+GimpImage* gimp_file_load           (GimpRunMode   run_mode,
+                                     const gchar  *filename,
+                                     const gchar  *raw_filename);
+GimpLayer* gimp_file_load_layer     (GimpRunMode   run_mode,
+                                     GimpImage    *image,
+                                     const gchar  *filename);
+gint*      gimp_file_load_layers    (GimpRunMode   run_mode,
+                                     GimpImage    *image,
+                                     const gchar  *filename,
+                                     gint         *num_layers);
+gboolean   gimp_file_save           (GimpRunMode   run_mode,
+                                     GimpImage    *image,
+                                     GimpDrawable *drawable,
+                                     const gchar  *filename,
+                                     const gchar  *raw_filename);
+gboolean   gimp_file_save_thumbnail (GimpImage    *image,
+                                     const gchar  *filename);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c
index 29c1b77ee3..e14c58a891 100644
--- a/libgimp/gimpfloatingsel_pdb.c
+++ b/libgimp/gimpfloatingsel_pdb.c
@@ -36,6 +36,46 @@
 
 /**
  * gimp_floating_sel_remove:
+ * @floating_sel: The floating selection.
+ *
+ * Remove the specified floating selection from its associated
+ * drawable.
+ *
+ * This procedure removes the floating selection completely, without
+ * any side effects. The associated drawable is then set to active.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_floating_sel_remove (GimpLayer *floating_sel)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (floating_sel)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-floating-sel-remove",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-floating-sel-remove",
+                                            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_floating_sel_remove: (skip)
  * @floating_sel_ID: The floating selection.
  *
  * Remove the specified floating selection from its associated
@@ -47,7 +87,7 @@
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_floating_sel_remove (gint32 floating_sel_ID)
+_gimp_floating_sel_remove (gint32 floating_sel_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -76,6 +116,47 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
 
 /**
  * gimp_floating_sel_anchor:
+ * @floating_sel: The floating selection.
+ *
+ * Anchor the specified floating selection to its associated drawable.
+ *
+ * This procedure anchors the floating selection to its associated
+ * drawable. This is similar to merging with a merge type of
+ * ClipToBottomLayer. The floating selection layer is no longer valid
+ * after this operation.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_floating_sel_anchor (GimpLayer *floating_sel)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (floating_sel)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-floating-sel-anchor",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-floating-sel-anchor",
+                                            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_floating_sel_anchor: (skip)
  * @floating_sel_ID: The floating selection.
  *
  * Anchor the specified floating selection to its associated drawable.
@@ -88,7 +169,7 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_floating_sel_anchor (gint32 floating_sel_ID)
+_gimp_floating_sel_anchor (gint32 floating_sel_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -117,6 +198,51 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
 
 /**
  * gimp_floating_sel_to_layer:
+ * @floating_sel: The floating selection.
+ *
+ * Transforms the specified floating selection into a layer.
+ *
+ * This procedure transforms the specified floating selection into a
+ * layer with the same offsets and extents. The composited image will
+ * look precisely the same, but the floating selection layer will no
+ * longer be clipped to the extents of the drawable it was attached to.
+ * The floating selection will become the active layer. This procedure
+ * will not work if the floating selection has a different base type
+ * from the underlying image. This might be the case if the floating
+ * selection is above an auxiliary channel or a layer mask.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_floating_sel_to_layer (GimpLayer *floating_sel)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (floating_sel)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-floating-sel-to-layer",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-floating-sel-to-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_floating_sel_to_layer: (skip)
  * @floating_sel_ID: The floating selection.
  *
  * Transforms the specified floating selection into a layer.
@@ -133,7 +259,7 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_floating_sel_to_layer (gint32 floating_sel_ID)
+_gimp_floating_sel_to_layer (gint32 floating_sel_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -162,6 +288,48 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
 
 /**
  * gimp_floating_sel_attach:
+ * @layer: The layer (is attached as floating selection).
+ * @drawable: The drawable (where to attach the floating selection).
+ *
+ * Attach the specified layer as floating to the specified drawable.
+ *
+ * This procedure attaches the layer as floating selection to the
+ * drawable.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_floating_sel_attach (GimpLayer    *layer,
+                          GimpDrawable *drawable)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-floating-sel-attach",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-floating-sel-attach",
+                                            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_floating_sel_attach: (skip)
  * @layer_ID: The layer (is attached as floating selection).
  * @drawable_ID: The drawable (where to attach the floating selection).
  *
@@ -173,8 +341,8 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_floating_sel_attach (gint32 layer_ID,
-                          gint32 drawable_ID)
+_gimp_floating_sel_attach (gint32 layer_ID,
+                           gint32 drawable_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpfloatingsel_pdb.h b/libgimp/gimpfloatingsel_pdb.h
index b8f9e631ae..38d557a34b 100644
--- a/libgimp/gimpfloatingsel_pdb.h
+++ b/libgimp/gimpfloatingsel_pdb.h
@@ -32,18 +32,22 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_floating_sel_remove   (gint32 floating_sel_ID);
-gboolean gimp_floating_sel_anchor   (gint32 floating_sel_ID);
-gboolean gimp_floating_sel_to_layer (gint32 floating_sel_ID);
-gboolean gimp_floating_sel_attach   (gint32 layer_ID,
-                                     gint32 drawable_ID);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+gboolean gimp_floating_sel_remove   (GimpLayer    *floating_sel);
+gboolean gimp_floating_sel_anchor   (GimpLayer    *floating_sel);
+gboolean gimp_floating_sel_to_layer (GimpLayer    *floating_sel);
+gboolean gimp_floating_sel_attach   (GimpLayer    *layer,
+                                     GimpDrawable *drawable);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_floating_sel_remove _gimp_floating_sel_remove
+#define gimp_floating_sel_anchor _gimp_floating_sel_anchor
+#define gimp_floating_sel_to_layer _gimp_floating_sel_to_layer
+#define gimp_floating_sel_attach _gimp_floating_sel_attach
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -52,7 +56,11 @@ gboolean gimp_floating_sel_attach   (gint32 layer_ID,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gboolean _gimp_floating_sel_remove   (gint32 floating_sel_ID);
+gboolean _gimp_floating_sel_anchor   (gint32 floating_sel_ID);
+gboolean _gimp_floating_sel_to_layer (gint32 floating_sel_ID);
+gboolean _gimp_floating_sel_attach   (gint32 layer_ID,
+                                      gint32 drawable_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index b3970d9e77..4221e39cc6 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -1267,15 +1267,15 @@ _gimp_image_get_vectors (gint32  image_ID,
  * layer mask and the layer mask is in edit mode, then the layer mask
  * is the active drawable.
  *
- * Returns: The active drawable.
+ * Returns: (transfer full): The active drawable.
  **/
-gint32
+GimpDrawable *
 gimp_image_get_active_drawable (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 drawable_ID = -1;
+  GimpDrawable *drawable = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -1291,11 +1291,11 @@ gimp_image_get_active_drawable (GimpImage *image)
   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));
+    drawable = GIMP_DRAWABLE (gimp_item_new_by_id (gimp_value_get_drawable_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return drawable_ID;
+  return drawable;
 }
 
 /**
@@ -1433,15 +1433,15 @@ _gimp_image_unset_active_channel (gint32 image_ID)
  * 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.
+ * Returns: (transfer full): The image's floating selection.
  **/
-gint32
+GimpLayer *
 gimp_image_get_floating_sel (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 floating_sel_ID = -1;
+  GimpLayer *floating_sel = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -1457,11 +1457,11 @@ gimp_image_get_floating_sel (GimpImage *image)
   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));
+    floating_sel = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return floating_sel_ID;
+  return floating_sel;
 }
 
 /**
@@ -1514,15 +1514,16 @@ _gimp_image_get_floating_sel (gint32 image_ID)
  * 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.
+ * Returns: (transfer full):
+ *          The drawable the floating selection is attached to.
  **/
-gint32
+GimpDrawable *
 gimp_image_floating_sel_attached_to (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 drawable_ID = -1;
+  GimpDrawable *drawable = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -1538,11 +1539,11 @@ gimp_image_floating_sel_attached_to (GimpImage *image)
   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));
+    drawable = GIMP_DRAWABLE (gimp_item_new_by_id (gimp_value_get_drawable_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return drawable_ID;
+  return drawable;
 }
 
 /**
@@ -1589,7 +1590,7 @@ _gimp_image_floating_sel_attached_to (gint32 image_ID)
 /**
  * gimp_image_pick_color:
  * @image: The image.
- * @drawable_ID: The drawable to pick from.
+ * @drawable: 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.
@@ -1614,14 +1615,14 @@ _gimp_image_floating_sel_attached_to (gint32 image_ID)
  * Returns: TRUE on success.
  **/
 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_image_pick_color (GimpImage    *image,
+                       GimpDrawable *drawable,
+                       gdouble       x,
+                       gdouble       y,
+                       gboolean      sample_merged,
+                       gboolean      sample_average,
+                       gdouble       average_radius,
+                       GimpRGB      *color)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1630,7 +1631,7 @@ gimp_image_pick_color (GimpImage *image,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_DOUBLE, x,
                                           G_TYPE_DOUBLE, y,
                                           G_TYPE_BOOLEAN, sample_merged,
@@ -1742,9 +1743,9 @@ _gimp_image_pick_color (gint32    image_ID,
  * at the specified coordinates. This procedure will return -1 if no
  * layer is found.
  *
- * Returns: The layer found at the specified coordinates.
+ * Returns: (transfer full): The layer found at the specified coordinates.
  **/
-gint32
+GimpLayer *
 gimp_image_pick_correlate_layer (GimpImage *image,
                                  gint       x,
                                  gint       y)
@@ -1752,7 +1753,7 @@ gimp_image_pick_correlate_layer (GimpImage *image,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -1770,11 +1771,11 @@ gimp_image_pick_correlate_layer (GimpImage *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -1829,8 +1830,8 @@ _gimp_image_pick_correlate_layer (gint32 image_ID,
 /**
  * gimp_image_insert_layer:
  * @image: The image.
- * @layer_ID: The layer.
- * @parent_ID: The parent layer.
+ * @layer: The layer.
+ * @parent: The parent layer.
  * @position: The layer position.
  *
  * Add the specified layer to the image.
@@ -1851,8 +1852,8 @@ _gimp_image_pick_correlate_layer (gint32 image_ID,
  **/
 gboolean
 gimp_image_insert_layer (GimpImage *image,
-                         gint32     layer_ID,
-                         gint32     parent_ID,
+                         GimpLayer *layer,
+                         GimpLayer *parent,
                          gint       position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
@@ -1862,8 +1863,8 @@ gimp_image_insert_layer (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,
-                                          GIMP_TYPE_LAYER_ID, parent_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (parent)),
                                           G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
@@ -1943,7 +1944,7 @@ _gimp_image_insert_layer (gint32 image_ID,
 /**
  * gimp_image_remove_layer:
  * @image: The image.
- * @layer_ID: The layer.
+ * @layer: The layer.
  *
  * Remove the specified layer from the image.
  *
@@ -1957,7 +1958,7 @@ _gimp_image_insert_layer (gint32 image_ID,
  **/
 gboolean
 gimp_image_remove_layer (GimpImage *image,
-                         gint32     layer_ID)
+                         GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1966,7 +1967,7 @@ gimp_image_remove_layer (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,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -2957,7 +2958,7 @@ _gimp_image_thaw_vectors (gint32 image_ID)
 /**
  * gimp_image_get_item_position:
  * @image: The image.
- * @item_ID: The item.
+ * @item: The item.
  *
  * Returns the position of the item in its level of its item tree.
  *
@@ -2972,7 +2973,7 @@ _gimp_image_thaw_vectors (gint32 image_ID)
  **/
 gint
 gimp_image_get_item_position (GimpImage *image,
-                              gint32     item_ID)
+                              GimpItem  *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -2981,7 +2982,7 @@ gimp_image_get_item_position (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,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -3051,7 +3052,7 @@ _gimp_image_get_item_position (gint32 image_ID,
 /**
  * gimp_image_raise_item:
  * @image: The image.
- * @item_ID: The item to raise.
+ * @item: The item to raise.
  *
  * Raise the specified item in its level in its item tree
  *
@@ -3064,7 +3065,7 @@ _gimp_image_get_item_position (gint32 image_ID,
  **/
 gboolean
 gimp_image_raise_item (GimpImage *image,
-                       gint32     item_ID)
+                       GimpItem  *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3073,7 +3074,7 @@ gimp_image_raise_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,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -3139,7 +3140,7 @@ _gimp_image_raise_item (gint32 image_ID,
 /**
  * gimp_image_lower_item:
  * @image: The image.
- * @item_ID: The item to lower.
+ * @item: The item to lower.
  *
  * Lower the specified item in its level in its item tree
  *
@@ -3152,7 +3153,7 @@ _gimp_image_raise_item (gint32 image_ID,
  **/
 gboolean
 gimp_image_lower_item (GimpImage *image,
-                       gint32     item_ID)
+                       GimpItem  *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3161,7 +3162,7 @@ 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,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -3227,7 +3228,7 @@ _gimp_image_lower_item (gint32 image_ID,
 /**
  * gimp_image_raise_item_to_top:
  * @image: The image.
- * @item_ID: The item to raise to top.
+ * @item: The item to raise to top.
  *
  * Raise the specified item to the top of its level in its item tree
  *
@@ -3240,7 +3241,7 @@ _gimp_image_lower_item (gint32 image_ID,
  **/
 gboolean
 gimp_image_raise_item_to_top (GimpImage *image,
-                              gint32     item_ID)
+                              GimpItem  *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3249,7 +3250,7 @@ gimp_image_raise_item_to_top (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,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -3315,7 +3316,7 @@ _gimp_image_raise_item_to_top (gint32 image_ID,
 /**
  * gimp_image_lower_item_to_bottom:
  * @image: The image.
- * @item_ID: The item to lower to bottom.
+ * @item: The item to lower to bottom.
  *
  * Lower the specified item to the bottom of its level in its item tree
  *
@@ -3329,7 +3330,7 @@ _gimp_image_raise_item_to_top (gint32 image_ID,
  **/
 gboolean
 gimp_image_lower_item_to_bottom (GimpImage *image,
-                                 gint32     item_ID)
+                                 GimpItem  *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -3338,7 +3339,7 @@ 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,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -3405,8 +3406,8 @@ _gimp_image_lower_item_to_bottom (gint32 image_ID,
 /**
  * gimp_image_reorder_item:
  * @image: The image.
- * @item_ID: The item to reorder.
- * @parent_ID: The new parent item.
+ * @item: The item to reorder.
+ * @parent: The new parent item.
  * @position: The new position of the item.
  *
  * Reorder the specified item within its item tree
@@ -3419,8 +3420,8 @@ _gimp_image_lower_item_to_bottom (gint32 image_ID,
  **/
 gboolean
 gimp_image_reorder_item (GimpImage *image,
-                         gint32     item_ID,
-                         gint32     parent_ID,
+                         GimpItem  *item,
+                         GimpItem  *parent,
                          gint       position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
@@ -3430,8 +3431,8 @@ gimp_image_reorder_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,
-                                          GIMP_TYPE_ITEM_ID, parent_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (parent)),
                                           G_TYPE_INT, position,
                                           G_TYPE_NONE);
 
@@ -3511,15 +3512,15 @@ _gimp_image_reorder_item (gint32 image_ID,
  * merging with the CLIP_TO_IMAGE merge type. Non-visible layers are
  * discarded, and the resulting image is stripped of its alpha channel.
  *
- * Returns: The resulting layer.
+ * Returns: (transfer full): The resulting layer.
  **/
-gint32
+GimpLayer *
 gimp_image_flatten (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -3535,11 +3536,11 @@ gimp_image_flatten (GimpImage *image)
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -3598,16 +3599,16 @@ _gimp_image_flatten (gint32 image_ID)
  * 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.
+ * Returns: (transfer full): The resulting layer.
  **/
-gint32
+GimpLayer *
 gimp_image_merge_visible_layers (GimpImage     *image,
                                  GimpMergeType  merge_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -3624,11 +3625,11 @@ gimp_image_merge_visible_layers (GimpImage     *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -3681,7 +3682,7 @@ _gimp_image_merge_visible_layers (gint32        image_ID,
 /**
  * gimp_image_merge_down:
  * @image: The image.
- * @merge_layer_ID: The layer to merge down from.
+ * @merge_layer: The layer to merge down from.
  * @merge_type: The type of merge.
  *
  * Merge the layer passed and the first visible layer below.
@@ -3694,21 +3695,21 @@ _gimp_image_merge_visible_layers (gint32        image_ID,
  * CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the
  * bottommost layer.
  *
- * Returns: The resulting layer.
+ * Returns: (transfer full): The resulting layer.
  **/
-gint32
+GimpLayer *
 gimp_image_merge_down (GimpImage     *image,
-                       gint32         merge_layer_ID,
+                       GimpLayer     *merge_layer,
                        GimpMergeType  merge_type)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   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_LAYER_ID, gimp_item_get_id (GIMP_ITEM (merge_layer)),
                                           GIMP_TYPE_MERGE_TYPE, merge_type,
                                           G_TYPE_NONE);
 
@@ -3722,11 +3723,11 @@ gimp_image_merge_down (GimpImage     *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -4467,15 +4468,15 @@ __gimp_image_thumbnail (gint32   image_ID,
  * 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.
+ * Returns: (transfer full): The active layer.
  **/
-gint32
+GimpLayer *
 gimp_image_get_active_layer (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 active_layer_ID = -1;
+  GimpLayer *active_layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -4491,11 +4492,11 @@ gimp_image_get_active_layer (GimpImage *image)
   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));
+    active_layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return active_layer_ID;
+  return active_layer;
 }
 
 /**
@@ -4542,7 +4543,7 @@ _gimp_image_get_active_layer (gint32 image_ID)
 /**
  * gimp_image_set_active_layer:
  * @image: The image.
- * @active_layer_ID: The new image active layer.
+ * @active_layer: The new image active layer.
  *
  * Sets the specified image's active layer.
  *
@@ -4555,7 +4556,7 @@ _gimp_image_get_active_layer (gint32 image_ID)
  **/
 gboolean
 gimp_image_set_active_layer (GimpImage *image,
-                             gint32     active_layer_ID)
+                             GimpLayer *active_layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -4564,7 +4565,7 @@ gimp_image_set_active_layer (GimpImage *image,
 
   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_LAYER_ID, gimp_item_get_id (GIMP_ITEM (active_layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -6595,16 +6596,16 @@ _gimp_image_set_tattoo_state (gint32 image_ID,
  * This procedure returns the layer with the given tattoo in the
  * specified image.
  *
- * Returns: The layer with the specified tattoo.
+ * Returns: (transfer full): The layer with the specified tattoo.
  **/
-gint32
+GimpLayer *
 gimp_image_get_layer_by_tattoo (GimpImage *image,
                                 guint      tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -6621,11 +6622,11 @@ gimp_image_get_layer_by_tattoo (GimpImage *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -6857,18 +6858,18 @@ _gimp_image_get_vectors_by_tattoo (gint32 image_ID,
  * This procedure returns the layer with the given name in the
  * specified image.
  *
- * Returns: The layer with the specified name.
+ * Returns: (transfer full): The layer with the specified name.
  *
  * Since: 2.8
  **/
-gint32
+GimpLayer *
 gimp_image_get_layer_by_name (GimpImage   *image,
                               const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -6885,11 +6886,11 @@ gimp_image_get_layer_by_name (GimpImage   *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h
index 0e0f76a73f..53b0885ffd 100644
--- a/libgimp/gimpimage_pdb.h
+++ b/libgimp/gimpimage_pdb.h
@@ -57,27 +57,27 @@ gint*                    gimp_image_get_channels               (GimpImage
                                                                 gint                *num_channels);
 gint*                    gimp_image_get_vectors                (GimpImage           *image,
                                                                 gint                *num_vectors);
-gint32                   gimp_image_get_active_drawable        (GimpImage           *image);
+GimpDrawable*            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);
+GimpLayer*               gimp_image_get_floating_sel           (GimpImage           *image);
+GimpDrawable*            gimp_image_floating_sel_attached_to   (GimpImage           *image);
 gboolean                 gimp_image_pick_color                 (GimpImage           *image,
-                                                                gint32               drawable_ID,
+                                                                GimpDrawable        *drawable,
                                                                 gdouble              x,
                                                                 gdouble              y,
                                                                 gboolean             sample_merged,
                                                                 gboolean             sample_average,
                                                                 gdouble              average_radius,
                                                                 GimpRGB             *color);
-gint32                   gimp_image_pick_correlate_layer       (GimpImage           *image,
+GimpLayer*               gimp_image_pick_correlate_layer       (GimpImage           *image,
                                                                 gint                 x,
                                                                 gint                 y);
 gboolean                 gimp_image_insert_layer               (GimpImage           *image,
-                                                                gint32               layer_ID,
-                                                                gint32               parent_ID,
+                                                                GimpLayer           *layer,
+                                                                GimpLayer           *parent,
                                                                 gint                 position);
 gboolean                 gimp_image_remove_layer               (GimpImage           *image,
-                                                                gint32               layer_ID);
+                                                                GimpLayer           *layer);
 gboolean                 gimp_image_freeze_layers              (GimpImage           *image);
 gboolean                 gimp_image_thaw_layers                (GimpImage           *image);
 gboolean                 gimp_image_insert_channel             (GimpImage           *image,
@@ -97,24 +97,24 @@ gboolean                 gimp_image_remove_vectors             (GimpImage
 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);
+                                                                GimpItem            *item);
 gboolean                 gimp_image_raise_item                 (GimpImage           *image,
-                                                                gint32               item_ID);
+                                                                GimpItem            *item);
 gboolean                 gimp_image_lower_item                 (GimpImage           *image,
-                                                                gint32               item_ID);
+                                                                GimpItem            *item);
 gboolean                 gimp_image_raise_item_to_top          (GimpImage           *image,
-                                                                gint32               item_ID);
+                                                                GimpItem            *item);
 gboolean                 gimp_image_lower_item_to_bottom       (GimpImage           *image,
-                                                                gint32               item_ID);
+                                                                GimpItem            *item);
 gboolean                 gimp_image_reorder_item               (GimpImage           *image,
-                                                                gint32               item_ID,
-                                                                gint32               parent_ID,
+                                                                GimpItem            *item,
+                                                                GimpItem            *parent,
                                                                 gint                 position);
-gint32                   gimp_image_flatten                    (GimpImage           *image);
-gint32                   gimp_image_merge_visible_layers       (GimpImage           *image,
+GimpLayer*               gimp_image_flatten                    (GimpImage           *image);
+GimpLayer*               gimp_image_merge_visible_layers       (GimpImage           *image,
                                                                 GimpMergeType        merge_type);
-gint32                   gimp_image_merge_down                 (GimpImage           *image,
-                                                                gint32               merge_layer_ID,
+GimpLayer*               gimp_image_merge_down                 (GimpImage           *image,
+                                                                GimpLayer           *merge_layer,
                                                                 GimpMergeType        merge_type);
 G_GNUC_INTERNAL guint8*  _gimp_image_get_colormap              (GimpImage           *image,
                                                                 gint                *num_bytes);
@@ -134,9 +134,9 @@ G_GNUC_INTERNAL gboolean _gimp_image_thumbnail                 (GimpImage
                                                                 gint                *bpp,
                                                                 gint                *thumbnail_data_count,
                                                                 guint8             **thumbnail_data);
-gint32                   gimp_image_get_active_layer           (GimpImage           *image);
+GimpLayer*               gimp_image_get_active_layer           (GimpImage           *image);
 gboolean                 gimp_image_set_active_layer           (GimpImage           *image,
-                                                                gint32               active_layer_ID);
+                                                                GimpLayer           *active_layer);
 gint32                   gimp_image_get_active_channel         (GimpImage           *image);
 gboolean                 gimp_image_set_active_channel         (GimpImage           *image,
                                                                 gint32               active_channel_ID);
@@ -174,13 +174,13 @@ gboolean                 gimp_image_set_unit                   (GimpImage
 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,
+GimpLayer*               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,
+GimpLayer*               gimp_image_get_layer_by_name          (GimpImage           *image,
                                                                 const gchar         *name);
 gint32                   gimp_image_get_channel_by_name        (GimpImage           *image,
                                                                 const gchar         *name);
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index c4e5ef3dea..efc229fb6a 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -38,7 +38,7 @@
  * gimp_image_select_color:
  * @image: The affected image.
  * @operation: The selection operation.
- * @drawable_ID: The affected drawable.
+ * @drawable: The affected drawable.
  * @color: The color to select.
  *
  * Create a selection by selecting all pixels (in the specified
@@ -68,7 +68,7 @@
 gboolean
 gimp_image_select_color (GimpImage      *image,
                          GimpChannelOps  operation,
-                         gint32          drawable_ID,
+                         GimpDrawable   *drawable,
                          const GimpRGB  *color)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
@@ -79,7 +79,7 @@ gimp_image_select_color (GimpImage      *image,
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
                                           GIMP_TYPE_CHANNEL_OPS, operation,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
 
@@ -168,7 +168,7 @@ _gimp_image_select_color (gint32          image_ID,
  * gimp_image_select_contiguous_color:
  * @image: The affected image.
  * @operation: The selection operation.
- * @drawable_ID: The affected drawable.
+ * @drawable: The affected drawable.
  * @x: x coordinate of initial seed fill point: (image coordinates).
  * @y: y coordinate of initial seed fill point: (image coordinates).
  *
@@ -208,7 +208,7 @@ _gimp_image_select_color (gint32          image_ID,
 gboolean
 gimp_image_select_contiguous_color (GimpImage      *image,
                                     GimpChannelOps  operation,
-                                    gint32          drawable_ID,
+                                    GimpDrawable   *drawable,
                                     gdouble         x,
                                     gdouble         y)
 {
@@ -220,7 +220,7 @@ gimp_image_select_contiguous_color (GimpImage      *image,
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
                                           GIMP_TYPE_CHANNEL_OPS, operation,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_DOUBLE, x,
                                           G_TYPE_DOUBLE, y,
                                           G_TYPE_NONE);
@@ -824,7 +824,7 @@ _gimp_image_select_polygon (gint32          image_ID,
  * gimp_image_select_item:
  * @image: The image.
  * @operation: The desired operation with current selection.
- * @item_ID: The item to render to the selection.
+ * @item: The item to render to the selection.
  *
  * Transforms the specified item into a selection
  *
@@ -844,7 +844,7 @@ _gimp_image_select_polygon (gint32          image_ID,
 gboolean
 gimp_image_select_item (GimpImage      *image,
                         GimpChannelOps  operation,
-                        gint32          item_ID)
+                        GimpItem       *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -854,7 +854,7 @@ gimp_image_select_item (GimpImage      *image,
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
                                           GIMP_TYPE_CHANNEL_OPS, operation,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
diff --git a/libgimp/gimpimageselect_pdb.h b/libgimp/gimpimageselect_pdb.h
index 5388112b4d..1bea2480b5 100644
--- a/libgimp/gimpimageselect_pdb.h
+++ b/libgimp/gimpimageselect_pdb.h
@@ -38,11 +38,11 @@ G_BEGIN_DECLS
 
 gboolean gimp_image_select_color            (GimpImage      *image,
                                              GimpChannelOps  operation,
-                                             gint32          drawable_ID,
+                                             GimpDrawable   *drawable,
                                              const GimpRGB  *color);
 gboolean gimp_image_select_contiguous_color (GimpImage      *image,
                                              GimpChannelOps  operation,
-                                             gint32          drawable_ID,
+                                             GimpDrawable   *drawable,
                                              gdouble         x,
                                              gdouble         y);
 gboolean gimp_image_select_rectangle        (GimpImage      *image,
@@ -71,7 +71,7 @@ gboolean gimp_image_select_polygon          (GimpImage      *image,
                                              const gdouble  *segs);
 gboolean gimp_image_select_item             (GimpImage      *image,
                                              GimpChannelOps  operation,
-                                             gint32          item_ID);
+                                             GimpItem       *item);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
diff --git a/libgimp/gimpitem.c b/libgimp/gimpitem.c
new file mode 100644
index 0000000000..f629dbbcba
--- /dev/null
+++ b/libgimp/gimpitem.c
@@ -0,0 +1,165 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball
+ *
+ * gimpitem.c
+ * Copyright (C) Jehan
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gimp.h"
+
+#include "gimppixbuf.h"
+
+enum
+{
+  PROP_0,
+  PROP_ID,
+  N_PROPS
+};
+
+struct _GimpItemPrivate
+{
+  gint id;
+};
+
+static void       gimp_item_set_property  (GObject      *object,
+                                            guint         property_id,
+                                            const GValue *value,
+                                            GParamSpec   *pspec);
+static void       gimp_item_get_property  (GObject      *object,
+                                            guint         property_id,
+                                            GValue       *value,
+                                            GParamSpec   *pspec);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpItem, gimp_item, G_TYPE_OBJECT)
+
+#define parent_class gimp_item_parent_class
+
+static GParamSpec *props[N_PROPS] = { NULL, };
+
+static void
+gimp_item_class_init (GimpItemClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->set_property = gimp_item_set_property;
+  object_class->get_property = gimp_item_get_property;
+
+  props[PROP_ID] =
+    g_param_spec_int ("id",
+                      "The item id",
+                      "The item id for internal use",
+                      0, G_MAXINT32, 0,
+                      GIMP_PARAM_READWRITE |
+                      G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, N_PROPS, props);
+}
+
+static void
+gimp_item_init (GimpItem *item)
+{
+  item->priv = gimp_item_get_instance_private (item);
+}
+
+static void
+gimp_item_set_property (GObject      *object,
+                         guint         property_id,
+                         const GValue *value,
+                         GParamSpec   *pspec)
+{
+  GimpItem *item = GIMP_ITEM (object);
+
+  switch (property_id)
+    {
+    case PROP_ID:
+      item->priv->id = g_value_get_int (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_item_get_property (GObject    *object,
+                         guint       property_id,
+                         GValue     *value,
+                         GParamSpec *pspec)
+{
+  GimpItem *item = GIMP_ITEM (object);
+
+  switch (property_id)
+    {
+    case PROP_ID:
+      g_value_set_int (value, item->priv->id);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+
+/* Public API. */
+
+
+/**
+ * gimp_item_get_id:
+ * @item: The item.
+ *
+ * Returns: the item ID.
+ *
+ * Since: 3.0
+ **/
+gint32
+gimp_item_get_id (GimpItem *item)
+{
+  return item ? item->priv->id : -1;
+}
+
+/**
+ * gimp_item_new_by_id:
+ * @item_id: The item id.
+ *
+ * Creates a #GimpItem representing @item_id. Since #GimpItem is an
+ * abstract class, the object real type will actually be the proper
+ * subclass.
+ *
+ * Returns: (nullable) (transfer full): a #GimpItem for @item_id or
+ *          %NULL if @item_id does not represent a valid item.
+ *
+ * Since: 3.0
+ **/
+GimpItem *
+gimp_item_new_by_id (gint32 item_id)
+{
+  GimpItem *item = NULL;
+
+  if (_gimp_item_is_valid (item_id))
+    {
+      if (_gimp_item_is_layer (item_id))
+        item = g_object_new (GIMP_TYPE_LAYER,
+                             "id", item_id,
+                             NULL);
+    }
+
+  return item;
+}
diff --git a/libgimp/gimpitem.h b/libgimp/gimpitem.h
new file mode 100644
index 0000000000..4880e72b09
--- /dev/null
+++ b/libgimp/gimpitem.h
@@ -0,0 +1,75 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball
+ *
+ * gimpitem.h
+ * Copyright (C) Jehan
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#if !defined (__GIMP_H_INSIDE__) && !defined (GIMP_COMPILATION)
+#error "Only <libgimp/gimp.h> can be included directly."
+#endif
+
+#ifndef __GIMP_ITEM_H__
+#define __GIMP_ITEM_H__
+
+G_BEGIN_DECLS
+
+/* For information look into the C source or the html documentation */
+
+#define GIMP_TYPE_ITEM            (gimp_item_get_type ())
+#define GIMP_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ITEM, GimpItem))
+#define GIMP_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ITEM, GimpItemClass))
+#define GIMP_IS_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ITEM))
+#define GIMP_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ITEM))
+#define GIMP_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM, GimpItemClass))
+
+
+typedef struct _GimpItemClass   GimpItemClass;
+typedef struct _GimpItemPrivate GimpItemPrivate;
+
+struct _GimpItem
+{
+  GObject           parent_instance;
+
+  GimpItemPrivate *priv;
+};
+
+struct _GimpItemClass
+{
+  GObjectClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gimp_reserved1) (void);
+  void (*_gimp_reserved2) (void);
+  void (*_gimp_reserved3) (void);
+  void (*_gimp_reserved4) (void);
+  void (*_gimp_reserved5) (void);
+  void (*_gimp_reserved6) (void);
+  void (*_gimp_reserved7) (void);
+  void (*_gimp_reserved8) (void);
+  void (*_gimp_reserved9) (void);
+};
+
+GType         gimp_item_get_type     (void) G_GNUC_CONST;
+
+gint32        gimp_item_get_id       (GimpItem    *item);
+GimpItem    * gimp_item_new_by_id    (gint32       item_id);
+
+
+G_END_DECLS
+
+#endif /* __GIMP_ITEM_H__ */
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index 1761d1b0b6..dfa4809d4f 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -36,6 +36,48 @@
 
 /**
  * gimp_item_is_valid:
+ * @item: The item to check.
+ *
+ * Returns TRUE if the item is valid.
+ *
+ * This procedure checks if the given item ID is valid and refers to an
+ * existing item.
+ *
+ * Returns: Whether the item ID is valid.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_is_valid (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean valid = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-is-valid",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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_item_is_valid: (skip)
  * @item_ID: The item to check.
  *
  * Returns TRUE if the item is valid.
@@ -48,7 +90,7 @@
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_valid (gint32 item_ID)
+_gimp_item_is_valid (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -78,7 +120,7 @@ gimp_item_is_valid (gint32 item_ID)
 
 /**
  * gimp_item_get_image:
- * @item_ID: The item.
+ * @item: The item.
  *
  * Returns the item's image.
  *
@@ -89,7 +131,7 @@ gimp_item_is_valid (gint32 item_ID)
  * Since: 2.8
  **/
 GimpImage *
-gimp_item_get_image (gint32 item_ID)
+gimp_item_get_image (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -97,7 +139,7 @@ gimp_item_get_image (gint32 item_ID)
   GimpImage *image = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -160,6 +202,50 @@ _gimp_item_get_image (gint32 item_ID)
 
 /**
  * gimp_item_delete:
+ * @item: The item to delete.
+ *
+ * Delete a item.
+ *
+ * This procedure deletes the specified item. This must not be done if
+ * the image containing this item was already deleted or if the item
+ * was already removed from the image. The only case in which this
+ * procedure is useful is if you want to get rid of a item which has
+ * not yet been added to an image.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_delete (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-delete",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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_item_delete: (skip)
  * @item_ID: The item to delete.
  *
  * Delete a item.
@@ -175,7 +261,7 @@ _gimp_item_get_image (gint32 item_ID)
  * Since: 2.8
  **/
 gboolean
-gimp_item_delete (gint32 item_ID)
+_gimp_item_delete (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -204,7 +290,7 @@ gimp_item_delete (gint32 item_ID)
 
 /**
  * gimp_item_is_drawable:
- * @item_ID: The item.
+ * @item: The item.
  *
  * Returns whether the item is a drawable.
  *
@@ -215,7 +301,7 @@ gimp_item_delete (gint32 item_ID)
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_drawable (gint32 item_ID)
+gimp_item_is_drawable (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -223,7 +309,7 @@ gimp_item_is_drawable (gint32 item_ID)
   gboolean drawable = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -244,24 +330,24 @@ gimp_item_is_drawable (gint32 item_ID)
 }
 
 /**
- * gimp_item_is_layer:
+ * _gimp_item_is_drawable: (skip)
  * @item_ID: The item.
  *
- * Returns whether the item is a layer.
+ * Returns whether the item is a drawable.
  *
- * This procedure returns TRUE if the specified item is a layer.
+ * This procedure returns TRUE if the specified item is a drawable.
  *
- * Returns: TRUE if the item is a layer, FALSE otherwise.
+ * Returns: TRUE if the item is a drawable, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_layer (gint32 item_ID)
+_gimp_item_is_drawable (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean layer = FALSE;
+  gboolean drawable = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -269,81 +355,81 @@ gimp_item_is_layer (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-layer",
+                                                "gimp-item-is-drawable",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-layer",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-drawable",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    drawable = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return layer;
+  return drawable;
 }
 
 /**
- * gimp_item_is_text_layer:
- * @item_ID: The item.
+ * gimp_item_is_layer:
+ * @item: The item.
  *
- * Returns whether the item is a text layer.
+ * Returns whether the item is a layer.
  *
- * This procedure returns TRUE if the specified item is a text layer.
+ * This procedure returns TRUE if the specified item is a layer.
  *
- * Returns: TRUE if the item is a text layer, FALSE otherwise.
+ * Returns: TRUE if the item is a layer, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_text_layer (gint32 item_ID)
+gimp_item_is_layer (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean text_layer = FALSE;
+  gboolean layer = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-text-layer",
+                                                "gimp-item-is-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-text-layer",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-layer",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    text_layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return text_layer;
+  return layer;
 }
 
 /**
- * gimp_item_is_channel:
+ * _gimp_item_is_layer: (skip)
  * @item_ID: The item.
  *
- * Returns whether the item is a channel.
+ * Returns whether the item is a layer.
  *
- * This procedure returns TRUE if the specified item is a channel.
+ * This procedure returns TRUE if the specified item is a layer.
  *
- * Returns: TRUE if the item is a channel, FALSE otherwise.
+ * Returns: TRUE if the item is a layer, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_channel (gint32 item_ID)
+_gimp_item_is_layer (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean channel = FALSE;
+  gboolean layer = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -351,81 +437,81 @@ gimp_item_is_channel (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-channel",
+                                                "gimp-item-is-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-channel",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-layer",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    channel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return channel;
+  return layer;
 }
 
 /**
- * gimp_item_is_layer_mask:
- * @item_ID: The item.
+ * gimp_item_is_text_layer:
+ * @item: The item.
  *
- * Returns whether the item is a layer mask.
+ * Returns whether the item is a text layer.
  *
- * This procedure returns TRUE if the specified item is a layer mask.
+ * This procedure returns TRUE if the specified item is a text layer.
  *
- * Returns: TRUE if the item is a layer mask, FALSE otherwise.
+ * Returns: TRUE if the item is a text layer, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_layer_mask (gint32 item_ID)
+gimp_item_is_text_layer (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean layer_mask = FALSE;
+  gboolean text_layer = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-layer-mask",
+                                                "gimp-item-is-text-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-layer-mask",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-text-layer",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    text_layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_mask;
+  return text_layer;
 }
 
 /**
- * gimp_item_is_selection:
+ * _gimp_item_is_text_layer: (skip)
  * @item_ID: The item.
  *
- * Returns whether the item is a selection.
+ * Returns whether the item is a text layer.
  *
- * This procedure returns TRUE if the specified item is a selection.
+ * This procedure returns TRUE if the specified item is a text layer.
  *
- * Returns: TRUE if the item is a selection, FALSE otherwise.
+ * Returns: TRUE if the item is a text layer, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_selection (gint32 item_ID)
+_gimp_item_is_text_layer (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean selection = FALSE;
+  gboolean text_layer = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -433,82 +519,81 @@ gimp_item_is_selection (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-selection",
+                                                "gimp-item-is-text-layer",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-selection",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-text-layer",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    selection = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    text_layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return selection;
+  return text_layer;
 }
 
 /**
- * gimp_item_is_vectors:
- * @item_ID: The item.
+ * gimp_item_is_channel:
+ * @item: The item.
  *
- * Returns whether the item is a vectors.
+ * Returns whether the item is a channel.
  *
- * This procedure returns TRUE if the specified item is a vectors.
+ * This procedure returns TRUE if the specified item is a channel.
  *
- * Returns: TRUE if the item is a vectors, FALSE otherwise.
+ * Returns: TRUE if the item is a channel, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_vectors (gint32 item_ID)
+gimp_item_is_channel (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean vectors = FALSE;
+  gboolean channel = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-vectors",
+                                                "gimp-item-is-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-vectors",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-channel",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    vectors = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    channel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return vectors;
+  return channel;
 }
 
 /**
- * gimp_item_is_group:
+ * _gimp_item_is_channel: (skip)
  * @item_ID: The item.
  *
- * Returns whether the item is a group item.
+ * Returns whether the item is a channel.
  *
- * This procedure returns TRUE if the specified item is a group item
- * which can have children.
+ * This procedure returns TRUE if the specified item is a channel.
  *
- * Returns: TRUE if the item is a group, FALSE otherwise.
+ * Returns: TRUE if the item is a channel, FALSE otherwise.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_is_group (gint32 item_ID)
+_gimp_item_is_channel (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean group = FALSE;
+  gboolean channel = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -516,86 +601,81 @@ gimp_item_is_group (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-is-group",
+                                                "gimp-item-is-channel",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-is-group",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-channel",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    group = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    channel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return group;
+  return channel;
 }
 
 /**
- * gimp_item_get_parent:
- * @item_ID: The item.
+ * gimp_item_is_layer_mask:
+ * @item: The item.
  *
- * Returns the item's parent item.
+ * Returns whether the item is a layer mask.
  *
- * This procedure returns the item's parent item, if any.
+ * This procedure returns TRUE if the specified item is a layer mask.
  *
- * Returns: The item's parent item.
+ * Returns: TRUE if the item is a layer mask, FALSE otherwise.
  *
  * Since: 2.8
  **/
-gint32
-gimp_item_get_parent (gint32 item_ID)
+gboolean
+gimp_item_is_layer_mask (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 parent_ID = -1;
+  gboolean layer_mask = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-parent",
+                                                "gimp-item-is-layer-mask",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-parent",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-layer-mask",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    parent_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+    layer_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return parent_ID;
+  return layer_mask;
 }
 
 /**
- * gimp_item_get_children:
+ * _gimp_item_is_layer_mask: (skip)
  * @item_ID: The item.
- * @num_children: (out): The item's number of children.
  *
- * Returns the item's list of children.
+ * Returns whether the item is a layer mask.
  *
- * This procedure returns the list of items which are children of the
- * specified item. The order is topmost to bottommost.
+ * This procedure returns TRUE if the specified item is a layer mask.
  *
- * Returns: (array length=num_children) (element-type gint32) (transfer full):
- *          The item's list of children.
- *          The returned value must be freed with g_free().
+ * Returns: TRUE if the item is a layer mask, FALSE otherwise.
  *
  * Since: 2.8
  **/
-gint *
-gimp_item_get_children (gint32  item_ID,
-                        gint   *num_children)
+gboolean
+_gimp_item_is_layer_mask (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint *child_ids = NULL;
+  gboolean layer_mask = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -603,45 +683,1186 @@ gimp_item_get_children (gint32  item_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-children",
+                                                "gimp-item-is-layer-mask",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-children",
+    return_vals = gimp_run_procedure_array ("gimp-item-is-layer-mask",
                                             args);
   gimp_value_array_unref (args);
 
-  *num_children = 0;
-
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      *num_children = g_value_get_int (gimp_value_array_index (return_vals, 1));
+    layer_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_mask;
+}
+
+/**
+ * gimp_item_is_selection:
+ * @item: The item.
+ *
+ * Returns whether the item is a selection.
+ *
+ * This procedure returns TRUE if the specified item is a selection.
+ *
+ * Returns: TRUE if the item is a selection, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_is_selection (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean selection = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-is-selection",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-selection",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    selection = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return selection;
+}
+
+/**
+ * _gimp_item_is_selection: (skip)
+ * @item_ID: The item.
+ *
+ * Returns whether the item is a selection.
+ *
+ * This procedure returns TRUE if the specified item is a selection.
+ *
+ * Returns: TRUE if the item is a selection, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_is_selection (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean selection = FALSE;
+
+  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-is-selection",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-selection",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    selection = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return selection;
+}
+
+/**
+ * gimp_item_is_vectors:
+ * @item: The item.
+ *
+ * Returns whether the item is a vectors.
+ *
+ * This procedure returns TRUE if the specified item is a vectors.
+ *
+ * Returns: TRUE if the item is a vectors, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_is_vectors (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean vectors = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-is-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    vectors = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return vectors;
+}
+
+/**
+ * _gimp_item_is_vectors: (skip)
+ * @item_ID: The item.
+ *
+ * Returns whether the item is a vectors.
+ *
+ * This procedure returns TRUE if the specified item is a vectors.
+ *
+ * Returns: TRUE if the item is a vectors, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_is_vectors (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean vectors = FALSE;
+
+  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-is-vectors",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-vectors",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    vectors = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return vectors;
+}
+
+/**
+ * gimp_item_is_group:
+ * @item: The item.
+ *
+ * Returns whether the item is a group item.
+ *
+ * This procedure returns TRUE if the specified item is a group item
+ * which can have children.
+ *
+ * Returns: TRUE if the item is a group, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_is_group (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean group = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-is-group",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-group",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    group = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return group;
+}
+
+/**
+ * _gimp_item_is_group: (skip)
+ * @item_ID: The item.
+ *
+ * Returns whether the item is a group item.
+ *
+ * This procedure returns TRUE if the specified item is a group item
+ * which can have children.
+ *
+ * Returns: TRUE if the item is a group, FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_is_group (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean group = FALSE;
+
+  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-is-group",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-is-group",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    group = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return group;
+}
+
+/**
+ * gimp_item_get_parent:
+ * @item: The item.
+ *
+ * Returns the item's parent item.
+ *
+ * This procedure returns the item's parent item, if any.
+ *
+ * Returns: (transfer full): The item's parent item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_get_parent (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *parent = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-parent",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-parent",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    parent = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return parent;
+}
+
+/**
+ * _gimp_item_get_parent: (skip)
+ * @item_ID: The item.
+ *
+ * Returns the item's parent item.
+ *
+ * This procedure returns the item's parent item, if any.
+ *
+ * Returns: The item's parent item.
+ *
+ * Since: 2.8
+ **/
+gint32
+_gimp_item_get_parent (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 parent_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-parent",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-parent",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    parent_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return parent_ID;
+}
+
+/**
+ * gimp_item_get_children:
+ * @item: The item.
+ * @num_children: (out): The item's number of children.
+ *
+ * Returns the item's list of children.
+ *
+ * This procedure returns the list of items which are children of the
+ * specified item. The order is topmost to bottommost.
+ *
+ * Returns: (array length=num_children) (element-type gint32) (transfer full):
+ *          The item's list of children.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gint *
+gimp_item_get_children (GimpItem *item,
+                        gint     *num_children)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *child_ids = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-children",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-children",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_children = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_children = g_value_get_int (gimp_value_array_index (return_vals, 1));
+      child_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return child_ids;
+}
+
+/**
+ * _gimp_item_get_children: (skip)
+ * @item_ID: The item.
+ * @num_children: (out): The item's number of children.
+ *
+ * Returns the item's list of children.
+ *
+ * This procedure returns the list of items which are children of the
+ * specified item. The order is topmost to bottommost.
+ *
+ * Returns: (array length=num_children): The item's list of children.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gint *
+_gimp_item_get_children (gint32  item_ID,
+                         gint   *num_children)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint *child_ids = NULL;
+
+  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-children",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-children",
+                                            args);
+  gimp_value_array_unref (args);
+
+  *num_children = 0;
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      *num_children = g_value_get_int (gimp_value_array_index (return_vals, 1));
       child_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
     }
 
   gimp_value_array_unref (return_vals);
 
-  return child_ids;
+  return child_ids;
+}
+
+/**
+ * gimp_item_get_expanded:
+ * @item: The item.
+ *
+ * Returns whether the item is expanded.
+ *
+ * This procedure returns TRUE if the specified item is expanded.
+ *
+ * Returns: TRUE if the item is expanded, FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_item_get_expanded (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean expanded = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-expanded",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-expanded",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    expanded = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return expanded;
+}
+
+/**
+ * _gimp_item_get_expanded: (skip)
+ * @item_ID: The item.
+ *
+ * Returns whether the item is expanded.
+ *
+ * This procedure returns TRUE if the specified item is expanded.
+ *
+ * Returns: TRUE if the item is expanded, FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_item_get_expanded (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean expanded = FALSE;
+
+  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-expanded",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-expanded",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    expanded = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return expanded;
+}
+
+/**
+ * gimp_item_set_expanded:
+ * @item: The item.
+ * @expanded: TRUE to expand the item, FALSE to collapse the item.
+ *
+ * Sets the expanded state of the item.
+ *
+ * This procedure expands or collapses the item.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_item_set_expanded (GimpItem *item,
+                        gboolean  expanded)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_BOOLEAN, expanded,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-expanded",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-expanded",
+                                            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_item_set_expanded: (skip)
+ * @item_ID: The item.
+ * @expanded: TRUE to expand the item, FALSE to collapse the item.
+ *
+ * Sets the expanded state of the item.
+ *
+ * This procedure expands or collapses the item.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_item_set_expanded (gint32   item_ID,
+                         gboolean expanded)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, expanded,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-expanded",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-expanded",
+                                            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_item_get_name:
+ * @item: The item.
+ *
+ * Get the name of the specified item.
+ *
+ * This procedure returns the specified item's name.
+ *
+ * Returns: (transfer full): The item name.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+gimp_item_get_name (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *name = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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_item_get_name: (skip)
+ * @item_ID: The item.
+ *
+ * Get the name of the specified item.
+ *
+ * This procedure returns the specified item's name.
+ *
+ * Returns: The item name.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.8
+ **/
+gchar *
+_gimp_item_get_name (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *name = NULL;
+
+  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-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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_item_set_name:
+ * @item: The item.
+ * @name: The new item name.
+ *
+ * Set the name of the specified item.
+ *
+ * This procedure sets the specified item's name.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_set_name (GimpItem    *item,
+                    const gchar *name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-name",
+                                            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_item_set_name: (skip)
+ * @item_ID: The item.
+ * @name: The new item name.
+ *
+ * Set the name of the specified item.
+ *
+ * This procedure sets the specified item's name.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_set_name (gint32       item_ID,
+                     const gchar *name)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-name",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-name",
+                                            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_item_get_visible:
+ * @item: The item.
+ *
+ * Get the visibility of the specified item.
+ *
+ * This procedure returns the specified item's visibility.
+ *
+ * Returns: The item visibility.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_get_visible (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean visible = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-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_item_get_visible: (skip)
+ * @item_ID: The item.
+ *
+ * Get the visibility of the specified item.
+ *
+ * This procedure returns the specified item's visibility.
+ *
+ * Returns: The item visibility.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_get_visible (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean visible = FALSE;
+
+  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-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-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_item_set_visible:
+ * @item: The item.
+ * @visible: The new item visibility.
+ *
+ * Set the visibility of the specified item.
+ *
+ * This procedure sets the specified item's visibility.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_set_visible (GimpItem *item,
+                       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_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_BOOLEAN, visible,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-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_item_set_visible: (skip)
+ * @item_ID: The item.
+ * @visible: The new item visibility.
+ *
+ * Set the visibility of the specified item.
+ *
+ * This procedure sets the specified item's visibility.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_set_visible (gint32   item_ID,
+                        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_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, visible,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-visible",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-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_item_get_linked:
+ * @item: The item.
+ *
+ * Get the linked state of the specified item.
+ *
+ * This procedure returns the specified item's linked state.
+ *
+ * Returns: The item linked state (for moves).
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_get_linked (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean linked = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-linked",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-linked",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    linked = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return linked;
+}
+
+/**
+ * _gimp_item_get_linked: (skip)
+ * @item_ID: The item.
+ *
+ * Get the linked state of the specified item.
+ *
+ * This procedure returns the specified item's linked state.
+ *
+ * Returns: The item linked state (for moves).
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_get_linked (gint32 item_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean linked = FALSE;
+
+  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-linked",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-linked",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    linked = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return linked;
+}
+
+/**
+ * gimp_item_set_linked:
+ * @item: The item.
+ * @linked: The new item linked state.
+ *
+ * Set the linked state of the specified item.
+ *
+ * This procedure sets the specified item's linked state.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_set_linked (GimpItem *item,
+                      gboolean  linked)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_BOOLEAN, linked,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-linked",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-linked",
+                                            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_item_set_linked: (skip)
+ * @item_ID: The item.
+ * @linked: The new item linked state.
+ *
+ * Set the linked state of the specified item.
+ *
+ * This procedure sets the specified item's linked state.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_item_set_linked (gint32   item_ID,
+                       gboolean linked)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, linked,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-set-linked",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-set-linked",
+                                            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_item_get_lock_content:
+ * @item: The item.
+ *
+ * Get the 'lock content' state of the specified item.
+ *
+ * This procedure returns the specified item's lock content state.
+ *
+ * Returns: Whether the item's contents are locked.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_item_get_lock_content (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean lock_content = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-lock-content",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-content",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    lock_content = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return lock_content;
 }
 
 /**
- * gimp_item_get_expanded:
+ * _gimp_item_get_lock_content: (skip)
  * @item_ID: The item.
  *
- * Returns whether the item is expanded.
+ * Get the 'lock content' state of the specified item.
  *
- * This procedure returns TRUE if the specified item is expanded.
+ * This procedure returns the specified item's lock content state.
  *
- * Returns: TRUE if the item is expanded, FALSE otherwise.
+ * Returns: Whether the item's contents are locked.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
 gboolean
-gimp_item_get_expanded (gint32 item_ID)
+_gimp_item_get_lock_content (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean expanded = FALSE;
+  gboolean lock_content = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -649,37 +1870,37 @@ gimp_item_get_expanded (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-expanded",
+                                                "gimp-item-get-lock-content",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-expanded",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-content",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    expanded = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    lock_content = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return expanded;
+  return lock_content;
 }
 
 /**
- * gimp_item_set_expanded:
- * @item_ID: The item.
- * @expanded: TRUE to expand the item, FALSE to collapse the item.
+ * gimp_item_set_lock_content:
+ * @item: The item.
+ * @lock_content: The new item 'lock content' state.
  *
- * Sets the expanded state of the item.
+ * Set the 'lock content' state of the specified item.
  *
- * This procedure expands or collapses the item.
+ * This procedure sets the specified item's lock content state.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
 gboolean
-gimp_item_set_expanded (gint32   item_ID,
-                        gboolean expanded)
+gimp_item_set_lock_content (GimpItem *item,
+                            gboolean  lock_content)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -687,16 +1908,16 @@ gimp_item_set_expanded (gint32   item_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_BOOLEAN, expanded,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_BOOLEAN, lock_content,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-expanded",
+                                                "gimp-item-set-lock-content",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-expanded",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-content",
                                             args);
   gimp_value_array_unref (args);
 
@@ -708,109 +1929,108 @@ gimp_item_set_expanded (gint32   item_ID,
 }
 
 /**
- * gimp_item_get_name:
+ * _gimp_item_set_lock_content: (skip)
  * @item_ID: The item.
+ * @lock_content: The new item 'lock content' state.
  *
- * Get the name of the specified item.
+ * Set the 'lock content' state of the specified item.
  *
- * This procedure returns the specified item's name.
+ * This procedure sets the specified item's lock content state.
  *
- * Returns: (transfer full): The item name.
- *          The returned value must be freed with g_free().
+ * Returns: TRUE on success.
  *
  * Since: 2.8
  **/
-gchar *
-gimp_item_get_name (gint32 item_ID)
+gboolean
+_gimp_item_set_lock_content (gint32   item_ID,
+                             gboolean lock_content)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *name = NULL;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, lock_content,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-name",
+                                                "gimp-item-set-lock-content",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-name",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-content",
                                             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));
+  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
 
   gimp_value_array_unref (return_vals);
 
-  return name;
+  return success;
 }
 
 /**
- * gimp_item_set_name:
- * @item_ID: The item.
- * @name: The new item name.
+ * gimp_item_get_lock_position:
+ * @item: The item.
  *
- * Set the name of the specified item.
+ * Get the 'lock position' state of the specified item.
  *
- * This procedure sets the specified item's name.
+ * This procedure returns the specified item's lock position state.
  *
- * Returns: TRUE on success.
+ * Returns: Whether the item's position is locked.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_set_name (gint32       item_ID,
-                    const gchar *name)
+gimp_item_get_lock_position (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gboolean lock_position = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-name",
+                                                "gimp-item-get-lock-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-name",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-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)
+    lock_position = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return lock_position;
 }
 
 /**
- * gimp_item_get_visible:
+ * _gimp_item_get_lock_position: (skip)
  * @item_ID: The item.
  *
- * Get the visibility of the specified item.
+ * Get the 'lock position' state of the specified item.
  *
- * This procedure returns the specified item's visibility.
+ * This procedure returns the specified item's lock position state.
  *
- * Returns: The item visibility.
+ * Returns: Whether the item's position is locked.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_get_visible (gint32 item_ID)
+_gimp_item_get_lock_position (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean visible = FALSE;
+  gboolean lock_position = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
@@ -818,37 +2038,37 @@ gimp_item_get_visible (gint32 item_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-visible",
+                                                "gimp-item-get-lock-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-visible",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-position",
                                             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));
+    lock_position = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return visible;
+  return lock_position;
 }
 
 /**
- * gimp_item_set_visible:
- * @item_ID: The item.
- * @visible: The new item visibility.
+ * gimp_item_set_lock_position:
+ * @item: The item.
+ * @lock_position: The new item 'lock position' state.
  *
- * Set the visibility of the specified item.
+ * Set the 'lock position' state of the specified item.
  *
- * This procedure sets the specified item's visibility.
+ * This procedure sets the specified item's lock position state.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_set_visible (gint32   item_ID,
-                       gboolean visible)
+gimp_item_set_lock_position (GimpItem *item,
+                             gboolean  lock_position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -856,16 +2076,16 @@ gimp_item_set_visible (gint32   item_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_BOOLEAN, visible,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_BOOLEAN, lock_position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-visible",
+                                                "gimp-item-set-lock-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-visible",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-position",
                                             args);
   gimp_value_array_unref (args);
 
@@ -877,146 +2097,189 @@ gimp_item_set_visible (gint32   item_ID,
 }
 
 /**
- * gimp_item_get_linked:
+ * _gimp_item_set_lock_position: (skip)
  * @item_ID: The item.
+ * @lock_position: The new item 'lock position' state.
  *
- * Get the linked state of the specified item.
+ * Set the 'lock position' state of the specified item.
  *
- * This procedure returns the specified item's linked state.
+ * This procedure sets the specified item's lock position state.
  *
- * Returns: The item linked state (for moves).
+ * Returns: TRUE on success.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_get_linked (gint32 item_ID)
+_gimp_item_set_lock_position (gint32   item_ID,
+                              gboolean lock_position)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean linked = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, lock_position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-linked",
+                                                "gimp-item-set-lock-position",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-linked",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-position",
+                                            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_item_get_color_tag:
+ * @item: The item.
+ *
+ * Get the color tag of the specified item.
+ *
+ * This procedure returns the specified item's color tag.
+ *
+ * Returns: The item's color tag.
+ *
+ * Since: 2.10
+ **/
+GimpColorTag
+gimp_item_get_color_tag (GimpItem *item)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpColorTag color_tag = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-color-tag",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-get-color-tag",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    linked = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    color_tag = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return linked;
+  return color_tag;
 }
 
 /**
- * gimp_item_set_linked:
+ * _gimp_item_get_color_tag: (skip)
  * @item_ID: The item.
- * @linked: The new item linked state.
  *
- * Set the linked state of the specified item.
+ * Get the color tag of the specified item.
  *
- * This procedure sets the specified item's linked state.
+ * This procedure returns the specified item's color tag.
  *
- * Returns: TRUE on success.
+ * Returns: The item's color tag.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
-gboolean
-gimp_item_set_linked (gint32   item_ID,
-                      gboolean linked)
+GimpColorTag
+_gimp_item_get_color_tag (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  GimpColorTag color_tag = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_BOOLEAN, linked,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-linked",
+                                                "gimp-item-get-color-tag",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-linked",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-color-tag",
                                             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)
+    color_tag = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return color_tag;
 }
 
 /**
- * gimp_item_get_lock_content:
- * @item_ID: The item.
+ * gimp_item_set_color_tag:
+ * @item: The item.
+ * @color_tag: The new item color tag.
  *
- * Get the 'lock content' state of the specified item.
+ * Set the color tag of the specified item.
  *
- * This procedure returns the specified item's lock content state.
+ * This procedure sets the specified item's color tag.
  *
- * Returns: Whether the item's contents are locked.
+ * Returns: TRUE on success.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_get_lock_content (gint32 item_ID)
+gimp_item_set_color_tag (GimpItem     *item,
+                         GimpColorTag  color_tag)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean lock_content = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          GIMP_TYPE_COLOR_TAG, color_tag,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-lock-content",
+                                                "gimp-item-set-color-tag",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-content",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-color-tag",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    lock_content = 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 lock_content;
+  return success;
 }
 
 /**
- * gimp_item_set_lock_content:
+ * _gimp_item_set_color_tag: (skip)
  * @item_ID: The item.
- * @lock_content: The new item 'lock content' state.
+ * @color_tag: The new item color tag.
  *
- * Set the 'lock content' state of the specified item.
+ * Set the color tag of the specified item.
  *
- * This procedure sets the specified item's lock content state.
+ * This procedure sets the specified item's color tag.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.8
+ * Since: 2.10
  **/
 gboolean
-gimp_item_set_lock_content (gint32   item_ID,
-                            gboolean lock_content)
+_gimp_item_set_color_tag (gint32       item_ID,
+                          GimpColorTag color_tag)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1025,15 +2288,15 @@ gimp_item_set_lock_content (gint32   item_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_BOOLEAN, lock_content,
+                                          GIMP_TYPE_COLOR_TAG, color_tag,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-lock-content",
+                                                "gimp-item-set-color-tag",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-content",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-color-tag",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1045,146 +2308,154 @@ gimp_item_set_lock_content (gint32   item_ID,
 }
 
 /**
- * gimp_item_get_lock_position:
- * @item_ID: The item.
+ * gimp_item_get_tattoo:
+ * @item: The item.
  *
- * Get the 'lock position' state of the specified item.
+ * Get the tattoo of the specified item.
  *
- * This procedure returns the specified item's lock position state.
+ * This procedure returns the specified item's tattoo. A tattoo is a
+ * unique and permanent identifier attached to a item that can be used
+ * to uniquely identify a item within an image even between sessions.
  *
- * Returns: Whether the item's position is locked.
+ * Returns: The item tattoo.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
-gboolean
-gimp_item_get_lock_position (gint32 item_ID)
+guint
+gimp_item_get_tattoo (GimpItem *item)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean lock_position = FALSE;
+  guint tattoo = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-lock-position",
+                                                "gimp-item-get-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-lock-position",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    lock_position = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    tattoo = g_value_get_uint (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return lock_position;
+  return tattoo;
 }
 
 /**
- * gimp_item_set_lock_position:
+ * _gimp_item_get_tattoo: (skip)
  * @item_ID: The item.
- * @lock_position: The new item 'lock position' state.
  *
- * Set the 'lock position' state of the specified item.
+ * Get the tattoo of the specified item.
  *
- * This procedure sets the specified item's lock position state.
+ * This procedure returns the specified item's tattoo. A tattoo is a
+ * unique and permanent identifier attached to a item that can be used
+ * to uniquely identify a item within an image even between sessions.
  *
- * Returns: TRUE on success.
+ * Returns: The item tattoo.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
-gboolean
-gimp_item_set_lock_position (gint32   item_ID,
-                             gboolean lock_position)
+guint
+_gimp_item_get_tattoo (gint32 item_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  guint tattoo = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_BOOLEAN, lock_position,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-lock-position",
+                                                "gimp-item-get-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-lock-position",
+    return_vals = gimp_run_procedure_array ("gimp-item-get-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)
+    tattoo = g_value_get_uint (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return tattoo;
 }
 
 /**
- * gimp_item_get_color_tag:
- * @item_ID: The item.
+ * gimp_item_set_tattoo:
+ * @item: The item.
+ * @tattoo: The new item tattoo.
  *
- * Get the color tag of the specified item.
+ * Set the tattoo of the specified item.
  *
- * This procedure returns the specified item's color tag.
+ * This procedure sets the specified item's tattoo. A tattoo is a
+ * unique and permanent identifier attached to a item that can be used
+ * to uniquely identify a item within an image even between sessions.
  *
- * Returns: The item's color tag.
+ * Returns: TRUE on success.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
-GimpColorTag
-gimp_item_get_color_tag (gint32 item_ID)
+gboolean
+gimp_item_set_tattoo (GimpItem *item,
+                      guint     tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpColorTag color_tag = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-color-tag",
+                                                "gimp-item-set-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-color-tag",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    color_tag = g_value_get_enum (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 color_tag;
+  return success;
 }
 
 /**
- * gimp_item_set_color_tag:
+ * _gimp_item_set_tattoo: (skip)
  * @item_ID: The item.
- * @color_tag: The new item color tag.
+ * @tattoo: The new item tattoo.
  *
- * Set the color tag of the specified item.
+ * Set the tattoo of the specified item.
  *
- * This procedure sets the specified item's color tag.
+ * This procedure sets the specified item's tattoo. A tattoo is a
+ * unique and permanent identifier attached to a item that can be used
+ * to uniquely identify a item within an image even between sessions.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.10
+ * Since: 2.8
  **/
 gboolean
-gimp_item_set_color_tag (gint32       item_ID,
-                         GimpColorTag color_tag)
+_gimp_item_set_tattoo (gint32 item_ID,
+                       guint  tattoo)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1193,15 +2464,15 @@ gimp_item_set_color_tag (gint32       item_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          GIMP_TYPE_COLOR_TAG, color_tag,
+                                          G_TYPE_UINT, tattoo,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-color-tag",
+                                                "gimp-item-set-tattoo",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-color-tag",
+    return_vals = gimp_run_procedure_array ("gimp-item-set-tattoo",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1213,66 +2484,66 @@ gimp_item_set_color_tag (gint32       item_ID,
 }
 
 /**
- * gimp_item_get_tattoo:
- * @item_ID: The item.
+ * gimp_item_attach_parasite:
+ * @item: The item.
+ * @parasite: The parasite to attach to the item.
  *
- * Get the tattoo of the specified item.
+ * Add a parasite to an item.
  *
- * This procedure returns the specified item's tattoo. A tattoo is a
- * unique and permanent identifier attached to a item that can be used
- * to uniquely identify a item within an image even between sessions.
+ * This procedure attaches a parasite to an item. It has no return
+ * values.
  *
- * Returns: The item tattoo.
+ * Returns: TRUE on success.
  *
  * Since: 2.8
  **/
-guint
-gimp_item_get_tattoo (gint32 item_ID)
+gboolean
+gimp_item_attach_parasite (GimpItem           *item,
+                           const GimpParasite *parasite)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  guint tattoo = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-get-tattoo",
+                                                "gimp-item-attach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-get-tattoo",
+    return_vals = gimp_run_procedure_array ("gimp-item-attach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    tattoo = g_value_get_uint (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 tattoo;
+  return success;
 }
 
 /**
- * gimp_item_set_tattoo:
+ * _gimp_item_attach_parasite: (skip)
  * @item_ID: The item.
- * @tattoo: The new item tattoo.
+ * @parasite: The parasite to attach to the item.
  *
- * Set the tattoo of the specified item.
+ * Add a parasite to an item.
  *
- * This procedure sets the specified item's tattoo. A tattoo is a
- * unique and permanent identifier attached to a item that can be used
- * to uniquely identify a item within an image even between sessions.
+ * This procedure attaches a parasite to an item. It has no return
+ * values.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.8
  **/
 gboolean
-gimp_item_set_tattoo (gint32 item_ID,
-                      guint  tattoo)
+_gimp_item_attach_parasite (gint32              item_ID,
+                            const GimpParasite *parasite)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1281,15 +2552,15 @@ gimp_item_set_tattoo (gint32 item_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_UINT, tattoo,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-set-tattoo",
+                                                "gimp-item-attach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-set-tattoo",
+    return_vals = gimp_run_procedure_array ("gimp-item-attach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1301,13 +2572,13 @@ gimp_item_set_tattoo (gint32 item_ID,
 }
 
 /**
- * gimp_item_attach_parasite:
- * @item_ID: The item.
- * @parasite: The parasite to attach to the item.
+ * gimp_item_detach_parasite:
+ * @item: The item.
+ * @name: The name of the parasite to detach from the item.
  *
- * Add a parasite to an item.
+ * Removes a parasite from an item.
  *
- * This procedure attaches a parasite to an item. It has no return
+ * This procedure detaches a parasite from an item. It has no return
  * values.
  *
  * Returns: TRUE on success.
@@ -1315,8 +2586,8 @@ gimp_item_set_tattoo (gint32 item_ID,
  * Since: 2.8
  **/
 gboolean
-gimp_item_attach_parasite (gint32              item_ID,
-                           const GimpParasite *parasite)
+gimp_item_detach_parasite (GimpItem    *item,
+                           const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1324,16 +2595,16 @@ gimp_item_attach_parasite (gint32              item_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
-                                          GIMP_TYPE_PARASITE, parasite,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-attach-parasite",
+                                                "gimp-item-detach-parasite",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-attach-parasite",
+    return_vals = gimp_run_procedure_array ("gimp-item-detach-parasite",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1345,7 +2616,7 @@ gimp_item_attach_parasite (gint32              item_ID,
 }
 
 /**
- * gimp_item_detach_parasite:
+ * _gimp_item_detach_parasite: (skip)
  * @item_ID: The item.
  * @name: The name of the parasite to detach from the item.
  *
@@ -1359,8 +2630,8 @@ gimp_item_attach_parasite (gint32              item_ID,
  * Since: 2.8
  **/
 gboolean
-gimp_item_detach_parasite (gint32       item_ID,
-                           const gchar *name)
+_gimp_item_detach_parasite (gint32       item_ID,
+                            const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1390,7 +2661,7 @@ gimp_item_detach_parasite (gint32       item_ID,
 
 /**
  * gimp_item_get_parasite:
- * @item_ID: The item.
+ * @item: The item.
  * @name: The name of the parasite to find.
  *
  * Look up a parasite in an item
@@ -1402,7 +2673,7 @@ gimp_item_detach_parasite (gint32       item_ID,
  * Since: 2.8
  **/
 GimpParasite *
-gimp_item_get_parasite (gint32       item_ID,
+gimp_item_get_parasite (GimpItem    *item,
                         const gchar *name)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
@@ -1410,6 +2681,50 @@ gimp_item_get_parasite (gint32       item_ID,
   GimpValueArray *return_vals;
   GimpParasite *parasite = NULL;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-parasite",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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_item_get_parasite: (skip)
+ * @item_ID: The item.
+ * @name: The name of the parasite to find.
+ *
+ * Look up a parasite in an item
+ *
+ * Finds and returns the parasite that is attached to an item.
+ *
+ * Returns: The found parasite.
+ *
+ * Since: 2.8
+ **/
+GimpParasite *
+_gimp_item_get_parasite (gint32       item_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_ITEM_ID, item_ID,
                                           G_TYPE_STRING, name,
@@ -1434,7 +2749,7 @@ gimp_item_get_parasite (gint32       item_ID,
 
 /**
  * gimp_item_get_parasite_list:
- * @item_ID: The item.
+ * @item: The item.
  * @num_parasites: (out): The number of attached parasites.
  *
  * List all parasites.
@@ -1448,8 +2763,58 @@ gimp_item_get_parasite (gint32       item_ID,
  * Since: 2.8
  **/
 gchar **
-gimp_item_get_parasite_list (gint32  item_ID,
-                             gint   *num_parasites)
+gimp_item_get_parasite_list (GimpItem *item,
+                             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_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-get-parasite-list",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-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;
+}
+
+/**
+ * _gimp_item_get_parasite_list: (skip)
+ * @item_ID: The item.
+ * @num_parasites: (out): The number of attached parasites.
+ *
+ * List all parasites.
+ *
+ * Returns a list of all parasites currently attached the an item.
+ *
+ * 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_item_get_parasite_list (gint32  item_ID,
+                              gint   *num_parasites)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpitem_pdb.h b/libgimp/gimpitem_pdb.h
index 9298f6ff88..a76f797dda 100644
--- a/libgimp/gimpitem_pdb.h
+++ b/libgimp/gimpitem_pdb.h
@@ -32,59 +32,92 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean      gimp_item_is_valid          (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,
+
+
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
+
+gboolean      gimp_item_is_valid          (GimpItem           *item);
+GimpImage*    gimp_item_get_image         (GimpItem           *item);
+gboolean      gimp_item_delete            (GimpItem           *item);
+gboolean      gimp_item_is_drawable       (GimpItem           *item);
+gboolean      gimp_item_is_layer          (GimpItem           *item);
+gboolean      gimp_item_is_text_layer     (GimpItem           *item);
+gboolean      gimp_item_is_channel        (GimpItem           *item);
+gboolean      gimp_item_is_layer_mask     (GimpItem           *item);
+gboolean      gimp_item_is_selection      (GimpItem           *item);
+gboolean      gimp_item_is_vectors        (GimpItem           *item);
+gboolean      gimp_item_is_group          (GimpItem           *item);
+GimpItem*     gimp_item_get_parent        (GimpItem           *item);
+gint*         gimp_item_get_children      (GimpItem           *item,
                                            gint               *num_children);
-gboolean      gimp_item_get_expanded      (gint32              item_ID);
-gboolean      gimp_item_set_expanded      (gint32              item_ID,
+gboolean      gimp_item_get_expanded      (GimpItem           *item);
+gboolean      gimp_item_set_expanded      (GimpItem           *item,
                                            gboolean            expanded);
-gchar*        gimp_item_get_name          (gint32              item_ID);
-gboolean      gimp_item_set_name          (gint32              item_ID,
+gchar*        gimp_item_get_name          (GimpItem           *item);
+gboolean      gimp_item_set_name          (GimpItem           *item,
                                            const gchar        *name);
-gboolean      gimp_item_get_visible       (gint32              item_ID);
-gboolean      gimp_item_set_visible       (gint32              item_ID,
+gboolean      gimp_item_get_visible       (GimpItem           *item);
+gboolean      gimp_item_set_visible       (GimpItem           *item,
                                            gboolean            visible);
-gboolean      gimp_item_get_linked        (gint32              item_ID);
-gboolean      gimp_item_set_linked        (gint32              item_ID,
+gboolean      gimp_item_get_linked        (GimpItem           *item);
+gboolean      gimp_item_set_linked        (GimpItem           *item,
                                            gboolean            linked);
-gboolean      gimp_item_get_lock_content  (gint32              item_ID);
-gboolean      gimp_item_set_lock_content  (gint32              item_ID,
+gboolean      gimp_item_get_lock_content  (GimpItem           *item);
+gboolean      gimp_item_set_lock_content  (GimpItem           *item,
                                            gboolean            lock_content);
-gboolean      gimp_item_get_lock_position (gint32              item_ID);
-gboolean      gimp_item_set_lock_position (gint32              item_ID,
+gboolean      gimp_item_get_lock_position (GimpItem           *item);
+gboolean      gimp_item_set_lock_position (GimpItem           *item,
                                            gboolean            lock_position);
-GimpColorTag  gimp_item_get_color_tag     (gint32              item_ID);
-gboolean      gimp_item_set_color_tag     (gint32              item_ID,
+GimpColorTag  gimp_item_get_color_tag     (GimpItem           *item);
+gboolean      gimp_item_set_color_tag     (GimpItem           *item,
                                            GimpColorTag        color_tag);
-guint         gimp_item_get_tattoo        (gint32              item_ID);
-gboolean      gimp_item_set_tattoo        (gint32              item_ID,
+guint         gimp_item_get_tattoo        (GimpItem           *item);
+gboolean      gimp_item_set_tattoo        (GimpItem           *item,
                                            guint               tattoo);
-gboolean      gimp_item_attach_parasite   (gint32              item_ID,
+gboolean      gimp_item_attach_parasite   (GimpItem           *item,
                                            const GimpParasite *parasite);
-gboolean      gimp_item_detach_parasite   (gint32              item_ID,
+gboolean      gimp_item_detach_parasite   (GimpItem           *item,
                                            const gchar        *name);
-GimpParasite* gimp_item_get_parasite      (gint32              item_ID,
+GimpParasite* gimp_item_get_parasite      (GimpItem           *item,
                                            const gchar        *name);
-gchar**       gimp_item_get_parasite_list (gint32              item_ID,
+gchar**       gimp_item_get_parasite_list (GimpItem           *item,
                                            gint               *num_parasites);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
-
-GimpImage* gimp_item_get_image (gint32 item_ID);
-
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_item_is_valid _gimp_item_is_valid
 #define gimp_item_get_image _gimp_item_get_image
+#define gimp_item_delete _gimp_item_delete
+#define gimp_item_is_drawable _gimp_item_is_drawable
+#define gimp_item_is_layer _gimp_item_is_layer
+#define gimp_item_is_text_layer _gimp_item_is_text_layer
+#define gimp_item_is_channel _gimp_item_is_channel
+#define gimp_item_is_layer_mask _gimp_item_is_layer_mask
+#define gimp_item_is_selection _gimp_item_is_selection
+#define gimp_item_is_vectors _gimp_item_is_vectors
+#define gimp_item_is_group _gimp_item_is_group
+#define gimp_item_get_parent _gimp_item_get_parent
+#define gimp_item_get_children _gimp_item_get_children
+#define gimp_item_get_expanded _gimp_item_get_expanded
+#define gimp_item_set_expanded _gimp_item_set_expanded
+#define gimp_item_get_name _gimp_item_get_name
+#define gimp_item_set_name _gimp_item_set_name
+#define gimp_item_get_visible _gimp_item_get_visible
+#define gimp_item_set_visible _gimp_item_set_visible
+#define gimp_item_get_linked _gimp_item_get_linked
+#define gimp_item_set_linked _gimp_item_set_linked
+#define gimp_item_get_lock_content _gimp_item_get_lock_content
+#define gimp_item_set_lock_content _gimp_item_set_lock_content
+#define gimp_item_get_lock_position _gimp_item_get_lock_position
+#define gimp_item_set_lock_position _gimp_item_set_lock_position
+#define gimp_item_get_color_tag _gimp_item_get_color_tag
+#define gimp_item_set_color_tag _gimp_item_set_color_tag
+#define gimp_item_get_tattoo _gimp_item_get_tattoo
+#define gimp_item_set_tattoo _gimp_item_set_tattoo
+#define gimp_item_attach_parasite _gimp_item_attach_parasite
+#define gimp_item_detach_parasite _gimp_item_detach_parasite
+#define gimp_item_get_parasite _gimp_item_get_parasite
+#define gimp_item_get_parasite_list _gimp_item_get_parasite_list
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -93,7 +126,52 @@ GimpImage* gimp_item_get_image (gint32 item_ID);
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-gint32 _gimp_item_get_image (gint32 item_ID);
+gboolean      _gimp_item_is_valid          (gint32              item_ID);
+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/gimpitemtransform_pdb.c b/libgimp/gimpitemtransform_pdb.c
index f7f3639400..285308b345 100644
--- a/libgimp/gimpitemtransform_pdb.c
+++ b/libgimp/gimpitemtransform_pdb.c
@@ -36,6 +36,61 @@
 
 /**
  * gimp_item_transform_translate:
+ * @item: The item.
+ * @off_x: Offset in x direction.
+ * @off_y: Offset in y direction.
+ *
+ * Translate the item by the specified offsets.
+ *
+ * This procedure translates the item by the amounts specified in the
+ * off_x and off_y arguments. These can be negative, and are considered
+ * offsets from the current position. The offsets will be rounded to
+ * the nearest pixel unless the item is a path.
+ *
+ * If the item is attached to an image and has its linked flag set to
+ * TRUE, all additional items contained in the image which have the
+ * linked flag set to TRUE will also be translated by the specified
+ * offsets.
+ *
+ * Returns: (transfer full): The translated item.
+ *
+ * Since: 2.10
+ **/
+GimpItem *
+gimp_item_transform_translate (GimpItem *item,
+                               gdouble   off_x,
+                               gdouble   off_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, off_x,
+                                          G_TYPE_DOUBLE, off_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-translate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-translate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_translate: (skip)
  * @item_ID: The item.
  * @off_x: Offset in x direction.
  * @off_y: Offset in y direction.
@@ -57,9 +112,9 @@
  * Since: 2.10
  **/
 gint32
-gimp_item_transform_translate (gint32  item_ID,
-                               gdouble off_x,
-                               gdouble off_y)
+_gimp_item_transform_translate (gint32  item_ID,
+                                gdouble off_x,
+                                gdouble off_y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -91,6 +146,74 @@ gimp_item_transform_translate (gint32  item_ID,
 
 /**
  * gimp_item_transform_flip_simple:
+ * @item: The affected item.
+ * @flip_type: Type of flip.
+ * @auto_center: Whether to automatically position the axis in the selection center.
+ * @axis: coord. of flip axis.
+ *
+ * Flip the specified item either vertically or horizontally.
+ *
+ * This procedure flips the specified item.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then flipped. If auto_center
+ * is set to TRUE, the flip is around the selection's center.
+ * Otherwise, the coordinate of the axis needs to be specified. The
+ * return value is the ID of the flipped floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be flipped around its center if auto_center is set to
+ * TRUE, otherwise the coordinate of the axis needs to be specified.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be flipped around the same axis. The return
+ * value will be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The flipped item.
+ *
+ * Since: 2.2
+ **/
+GimpItem *
+gimp_item_transform_flip_simple (GimpItem            *item,
+                                 GimpOrientationType  flip_type,
+                                 gboolean             auto_center,
+                                 gdouble              axis)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          GIMP_TYPE_ORIENTATION_TYPE, flip_type,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, axis,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-flip-simple",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-flip-simple",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_flip_simple: (skip)
  * @item_ID: The affected item.
  * @flip_type: Type of flip.
  * @auto_center: Whether to automatically position the axis in the selection center.
@@ -123,10 +246,10 @@ gimp_item_transform_translate (gint32  item_ID,
  * Since: 2.2
  **/
 gint32
-gimp_item_transform_flip_simple (gint32              item_ID,
-                                 GimpOrientationType flip_type,
-                                 gboolean            auto_center,
-                                 gdouble             axis)
+_gimp_item_transform_flip_simple (gint32              item_ID,
+                                  GimpOrientationType flip_type,
+                                  gboolean            auto_center,
+                                  gdouble             axis)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -159,6 +282,77 @@ gimp_item_transform_flip_simple (gint32              item_ID,
 
 /**
  * gimp_item_transform_flip:
+ * @item: The affected item.
+ * @x0: horz. coord. of one end of axis.
+ * @y0: vert. coord. of one end of axis.
+ * @x1: horz. coord. of other end of axis.
+ * @y1: vert. coord. of other end of axis.
+ *
+ * Flip the specified item around a given line.
+ *
+ * This procedure flips the specified item.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then flipped. The axis to
+ * flip around is specified by specifying two points from that line.
+ * The return value is the ID of the flipped floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be flipped around the specified axis. Additionally, if the
+ * item has its linked flag set to TRUE, all additional items contained
+ * in the image which have the linked flag set to TRUE will also be
+ * flipped around the same axis. The return value will be equal to the
+ * item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The flipped item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_flip (GimpItem *item,
+                          gdouble   x0,
+                          gdouble   y0,
+                          gdouble   x1,
+                          gdouble   y1)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-flip",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-flip",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_flip: (skip)
  * @item_ID: The affected item.
  * @x0: horz. coord. of one end of axis.
  * @y0: vert. coord. of one end of axis.
@@ -192,11 +386,11 @@ gimp_item_transform_flip_simple (gint32              item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_flip (gint32  item_ID,
-                          gdouble x0,
-                          gdouble y0,
-                          gdouble x1,
-                          gdouble y1)
+_gimp_item_transform_flip (gint32  item_ID,
+                           gdouble x0,
+                           gdouble y0,
+                           gdouble x1,
+                           gdouble y1)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -230,6 +424,98 @@ gimp_item_transform_flip (gint32  item_ID,
 
 /**
  * gimp_item_transform_perspective:
+ * @item: The affected item.
+ * @x0: The new x coordinate of upper-left corner of original bounding box.
+ * @y0: The new y coordinate of upper-left corner of original bounding box.
+ * @x1: The new x coordinate of upper-right corner of original bounding box.
+ * @y1: The new y coordinate of upper-right corner of original bounding box.
+ * @x2: The new x coordinate of lower-left corner of original bounding box.
+ * @y2: The new y coordinate of lower-left corner of original bounding box.
+ * @x3: The new x coordinate of lower-right corner of original bounding box.
+ * @y3: The new y coordinate of lower-right corner of original bounding box.
+ *
+ * Perform a possibly non-affine transformation on the specified item.
+ *
+ * This procedure performs a possibly non-affine transformation on the
+ * specified item by allowing the corners of the original bounding box
+ * to be arbitrarily remapped to any values.
+ *
+ * The 4 coordinates specify the new locations of each corner of the
+ * original bounding box. By specifying these values, any affine
+ * transformation (rotation, scaling, translation) can be affected.
+ * Additionally, these values can be specified such that the resulting
+ * transformed item will appear to have been projected via a
+ * perspective transform.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then transformed as
+ * specified. The return value is the ID of the transformed floating
+ * selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be transformed according to the specified mapping.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be transformed the same way. The return value
+ * will be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The transformed item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_perspective (GimpItem *item,
+                                 gdouble   x0,
+                                 gdouble   y0,
+                                 gdouble   x1,
+                                 gdouble   y1,
+                                 gdouble   x2,
+                                 gdouble   y2,
+                                 gdouble   x3,
+                                 gdouble   y3)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
+                                          G_TYPE_DOUBLE, x3,
+                                          G_TYPE_DOUBLE, y3,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-perspective",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-perspective",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_perspective: (skip)
  * @item_ID: The affected item.
  * @x0: The new x coordinate of upper-left corner of original bounding box.
  * @y0: The new y coordinate of upper-left corner of original bounding box.
@@ -276,15 +562,15 @@ gimp_item_transform_flip (gint32  item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_perspective (gint32  item_ID,
-                                 gdouble x0,
-                                 gdouble y0,
-                                 gdouble x1,
-                                 gdouble y1,
-                                 gdouble x2,
-                                 gdouble y2,
-                                 gdouble x3,
-                                 gdouble y3)
+_gimp_item_transform_perspective (gint32  item_ID,
+                                  gdouble x0,
+                                  gdouble y0,
+                                  gdouble x1,
+                                  gdouble y1,
+                                  gdouble x2,
+                                  gdouble y2,
+                                  gdouble x3,
+                                  gdouble y3)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -322,7 +608,7 @@ gimp_item_transform_perspective (gint32  item_ID,
 
 /**
  * gimp_item_transform_rotate_simple:
- * @item_ID: The affected item.
+ * @item: The affected item.
  * @rotate_type: Type of rotation.
  * @auto_center: Whether to automatically rotate around the selection center.
  * @center_x: The hor. coordinate of the center of rotation.
@@ -353,24 +639,24 @@ gimp_item_transform_perspective (gint32  item_ID,
  * This procedure is affected by the following context setters:
  * gimp_context_set_transform_resize().
  *
- * Returns: The rotated item.
+ * Returns: (transfer full): The rotated item.
  *
  * Since: 2.8
  **/
-gint32
-gimp_item_transform_rotate_simple (gint32           item_ID,
-                                   GimpRotationType rotate_type,
-                                   gboolean         auto_center,
-                                   gdouble          center_x,
-                                   gdouble          center_y)
+GimpItem *
+gimp_item_transform_rotate_simple (GimpItem         *item,
+                                   GimpRotationType  rotate_type,
+                                   gboolean          auto_center,
+                                   gdouble           center_x,
+                                   gdouble           center_y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 ret_item_ID = -1;
+  GimpItem *ret_item = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
                                           GIMP_TYPE_ROTATION_TYPE, rotate_type,
                                           G_TYPE_BOOLEAN, auto_center,
                                           G_TYPE_DOUBLE, center_x,
@@ -387,17 +673,17 @@ gimp_item_transform_rotate_simple (gint32           item_ID,
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
 
   gimp_value_array_unref (return_vals);
 
-  return ret_item_ID;
+  return ret_item;
 }
 
 /**
- * gimp_item_transform_rotate:
+ * _gimp_item_transform_rotate_simple: (skip)
  * @item_ID: The affected item.
- * @angle: The angle of rotation (radians).
+ * @rotate_type: Type of rotation.
  * @auto_center: Whether to automatically rotate around the selection center.
  * @center_x: The hor. coordinate of the center of rotation.
  * @center_y: The vert. coordinate of the center of rotation.
@@ -425,8 +711,6 @@ gimp_item_transform_rotate_simple (gint32           item_ID,
  * input.
  *
  * This procedure is affected by the following context setters:
- * gimp_context_set_interpolation(),
- * gimp_context_set_transform_direction(),
  * gimp_context_set_transform_resize().
  *
  * Returns: The rotated item.
@@ -434,11 +718,11 @@ gimp_item_transform_rotate_simple (gint32           item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_rotate (gint32   item_ID,
-                            gdouble  angle,
-                            gboolean auto_center,
-                            gdouble  center_x,
-                            gdouble  center_y)
+_gimp_item_transform_rotate_simple (gint32           item_ID,
+                                    GimpRotationType rotate_type,
+                                    gboolean         auto_center,
+                                    gdouble          center_x,
+                                    gdouble          center_y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -447,7 +731,7 @@ gimp_item_transform_rotate (gint32   item_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_ITEM_ID, item_ID,
-                                          G_TYPE_DOUBLE, angle,
+                                          GIMP_TYPE_ROTATION_TYPE, rotate_type,
                                           G_TYPE_BOOLEAN, auto_center,
                                           G_TYPE_DOUBLE, center_x,
                                           G_TYPE_DOUBLE, center_y,
@@ -455,10 +739,10 @@ gimp_item_transform_rotate (gint32   item_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-item-transform-rotate",
+                                                "gimp-item-transform-rotate-simple",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate",
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate-simple",
                                             args);
   gimp_value_array_unref (args);
 
@@ -471,7 +755,232 @@ gimp_item_transform_rotate (gint32   item_ID,
 }
 
 /**
- * gimp_item_transform_scale:
+ * gimp_item_transform_rotate:
+ * @item: The affected item.
+ * @angle: The angle of rotation (radians).
+ * @auto_center: Whether to automatically rotate around the selection center.
+ * @center_x: The hor. coordinate of the center of rotation.
+ * @center_y: The vert. coordinate of the center of rotation.
+ *
+ * Rotate the specified item about given coordinates through the
+ * specified angle.
+ *
+ * This function rotates the specified item.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then rotated by the
+ * specified amount. If auto_center is set to TRUE, the rotation is
+ * around the selection's center. Otherwise, the coordinate of the
+ * center point needs to be specified. The return value is the ID of
+ * the rotated floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be rotated around its center if auto_center is set to
+ * TRUE, otherwise the coordinate of the center point needs to be
+ * specified. Additionally, if the item has its linked flag set to
+ * TRUE, all additional items contained in the image which have the
+ * linked flag set to TRUE will also be rotated around the same center
+ * point. The return value will be equal to the item ID supplied as
+ * input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The rotated item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_rotate (GimpItem *item,
+                            gdouble   angle,
+                            gboolean  auto_center,
+                            gdouble   center_x,
+                            gdouble   center_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, angle,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, center_x,
+                                          G_TYPE_DOUBLE, center_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-rotate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_rotate: (skip)
+ * @item_ID: The affected item.
+ * @angle: The angle of rotation (radians).
+ * @auto_center: Whether to automatically rotate around the selection center.
+ * @center_x: The hor. coordinate of the center of rotation.
+ * @center_y: The vert. coordinate of the center of rotation.
+ *
+ * Rotate the specified item about given coordinates through the
+ * specified angle.
+ *
+ * This function rotates the specified item.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then rotated by the
+ * specified amount. If auto_center is set to TRUE, the rotation is
+ * around the selection's center. Otherwise, the coordinate of the
+ * center point needs to be specified. The return value is the ID of
+ * the rotated floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be rotated around its center if auto_center is set to
+ * TRUE, otherwise the coordinate of the center point needs to be
+ * specified. Additionally, if the item has its linked flag set to
+ * TRUE, all additional items contained in the image which have the
+ * linked flag set to TRUE will also be rotated around the same center
+ * point. The return value will be equal to the item ID supplied as
+ * input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: The rotated item.
+ *
+ * Since: 2.8
+ **/
+gint32
+_gimp_item_transform_rotate (gint32   item_ID,
+                             gdouble  angle,
+                             gboolean auto_center,
+                             gdouble  center_x,
+                             gdouble  center_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 ret_item_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, angle,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, center_x,
+                                          G_TYPE_DOUBLE, center_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-rotate",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item_ID;
+}
+
+/**
+ * gimp_item_transform_scale:
+ * @item: The affected item.
+ * @x0: The new x coordinate of the upper-left corner of the scaled region.
+ * @y0: The new y coordinate of the upper-left corner of the scaled region.
+ * @x1: The new x coordinate of the lower-right corner of the scaled region.
+ * @y1: The new y coordinate of the lower-right corner of the scaled region.
+ *
+ * Scale the specified item.
+ *
+ * This procedure scales the specified item.
+ *
+ * The 2 coordinates specify the new locations of the top-left and
+ * bottom-roght corners of the original bounding box.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then scaled as specified.
+ * The return value is the ID of the scaled floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be scaled according to the specified coordinates.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be scaled the same way. The return value will
+ * be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The scaled item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_scale (GimpItem *item,
+                           gdouble   x0,
+                           gdouble   y0,
+                           gdouble   x1,
+                           gdouble   y1)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-scale",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-scale",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_scale: (skip)
  * @item_ID: The affected item.
  * @x0: The new x coordinate of the upper-left corner of the scaled region.
  * @y0: The new y coordinate of the upper-left corner of the scaled region.
@@ -507,11 +1016,11 @@ gimp_item_transform_rotate (gint32   item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_scale (gint32  item_ID,
-                           gdouble x0,
-                           gdouble y0,
-                           gdouble x1,
-                           gdouble y1)
+_gimp_item_transform_scale (gint32  item_ID,
+                            gdouble x0,
+                            gdouble y0,
+                            gdouble x1,
+                            gdouble y1)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -545,6 +1054,75 @@ gimp_item_transform_scale (gint32  item_ID,
 
 /**
  * gimp_item_transform_shear:
+ * @item: The affected item.
+ * @shear_type: Type of shear.
+ * @magnitude: The magnitude of the shear.
+ *
+ * Shear the specified item about its center by the specified
+ * magnitude.
+ *
+ * This procedure shears the specified item.
+ *
+ * The shear type parameter indicates whether the shear will be applied
+ * horizontally or vertically. The magnitude can be either positive or
+ * negative and indicates the extent (in pixels) to shear by.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then sheared as specified.
+ * The return value is the ID of the sheared floating selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be sheared according to the specified parameters.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be sheared the same way. The return value will
+ * be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The sheared item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_shear (GimpItem            *item,
+                           GimpOrientationType  shear_type,
+                           gdouble              magnitude)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          GIMP_TYPE_ORIENTATION_TYPE, shear_type,
+                                          G_TYPE_DOUBLE, magnitude,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-shear",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-shear",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_shear: (skip)
  * @item_ID: The affected item.
  * @shear_type: Type of shear.
  * @magnitude: The magnitude of the shear.
@@ -580,9 +1158,9 @@ gimp_item_transform_scale (gint32  item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_shear (gint32              item_ID,
-                           GimpOrientationType shear_type,
-                           gdouble             magnitude)
+_gimp_item_transform_shear (gint32              item_ID,
+                            GimpOrientationType shear_type,
+                            gdouble             magnitude)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -614,6 +1192,91 @@ gimp_item_transform_shear (gint32              item_ID,
 
 /**
  * gimp_item_transform_2d:
+ * @item: The affected item.
+ * @source_x: X coordinate of the transformation center.
+ * @source_y: Y coordinate of the transformation center.
+ * @scale_x: Amount to scale in x direction.
+ * @scale_y: Amount to scale in y direction.
+ * @angle: The angle of rotation (radians).
+ * @dest_x: X coordinate of where the center goes.
+ * @dest_y: Y coordinate of where the center goes.
+ *
+ * Transform the specified item in 2d.
+ *
+ * This procedure transforms the specified item.
+ *
+ * The transformation is done by scaling by the x and y scale factors
+ * about the point (source_x, source_y), then rotating around the same
+ * point, then translating that point to the new position (dest_x,
+ * dest_y).
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then transformed as
+ * specified. The return value is the ID of the transformed floating
+ * selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be transformed according to the specified parameters.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be transformed the same way. The return value
+ * will be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The transformed item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_2d (GimpItem *item,
+                        gdouble   source_x,
+                        gdouble   source_y,
+                        gdouble   scale_x,
+                        gdouble   scale_y,
+                        gdouble   angle,
+                        gdouble   dest_x,
+                        gdouble   dest_y)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, source_x,
+                                          G_TYPE_DOUBLE, source_y,
+                                          G_TYPE_DOUBLE, scale_x,
+                                          G_TYPE_DOUBLE, scale_y,
+                                          G_TYPE_DOUBLE, angle,
+                                          G_TYPE_DOUBLE, dest_x,
+                                          G_TYPE_DOUBLE, dest_y,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-2d",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-2d",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_2d: (skip)
  * @item_ID: The affected item.
  * @source_x: X coordinate of the transformation center.
  * @source_y: Y coordinate of the transformation center.
@@ -655,14 +1318,14 @@ gimp_item_transform_shear (gint32              item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_2d (gint32  item_ID,
-                        gdouble source_x,
-                        gdouble source_y,
-                        gdouble scale_x,
-                        gdouble scale_y,
-                        gdouble angle,
-                        gdouble dest_x,
-                        gdouble dest_y)
+_gimp_item_transform_2d (gint32  item_ID,
+                         gdouble source_x,
+                         gdouble source_y,
+                         gdouble scale_x,
+                         gdouble scale_y,
+                         gdouble angle,
+                         gdouble dest_x,
+                         gdouble dest_y)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -699,6 +1362,95 @@ gimp_item_transform_2d (gint32  item_ID,
 
 /**
  * gimp_item_transform_matrix:
+ * @item: The affected item.
+ * @coeff_0_0: coefficient (0,0) of the transformation matrix.
+ * @coeff_0_1: coefficient (0,1) of the transformation matrix.
+ * @coeff_0_2: coefficient (0,2) of the transformation matrix.
+ * @coeff_1_0: coefficient (1,0) of the transformation matrix.
+ * @coeff_1_1: coefficient (1,1) of the transformation matrix.
+ * @coeff_1_2: coefficient (1,2) of the transformation matrix.
+ * @coeff_2_0: coefficient (2,0) of the transformation matrix.
+ * @coeff_2_1: coefficient (2,1) of the transformation matrix.
+ * @coeff_2_2: coefficient (2,2) of the transformation matrix.
+ *
+ * Transform the specified item in 2d.
+ *
+ * This procedure transforms the specified item.
+ *
+ * The transformation is done by assembling a 3x3 matrix from the
+ * coefficients passed.
+ *
+ * If a selection exists and the item is a drawable, the portion of the
+ * drawable which lies under the selection is cut from the drawable and
+ * made into a floating selection which is then transformed as
+ * specified. The return value is the ID of the transformed floating
+ * selection.
+ *
+ * If there is no selection or the item is not a drawable, the entire
+ * item will be transformed according to the specified matrix.
+ * Additionally, if the item has its linked flag set to TRUE, all
+ * additional items contained in the image which have the linked flag
+ * set to TRUE will also be transformed the same way. The return value
+ * will be equal to the item ID supplied as input.
+ *
+ * This procedure is affected by the following context setters:
+ * gimp_context_set_interpolation(),
+ * gimp_context_set_transform_direction(),
+ * gimp_context_set_transform_resize().
+ *
+ * Returns: (transfer full): The transformed item.
+ *
+ * Since: 2.8
+ **/
+GimpItem *
+gimp_item_transform_matrix (GimpItem *item,
+                            gdouble   coeff_0_0,
+                            gdouble   coeff_0_1,
+                            gdouble   coeff_0_2,
+                            gdouble   coeff_1_0,
+                            gdouble   coeff_1_1,
+                            gdouble   coeff_1_2,
+                            gdouble   coeff_2_0,
+                            gdouble   coeff_2_1,
+                            gdouble   coeff_2_2)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpItem *ret_item = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, gimp_item_get_id (GIMP_ITEM (item)),
+                                          G_TYPE_DOUBLE, coeff_0_0,
+                                          G_TYPE_DOUBLE, coeff_0_1,
+                                          G_TYPE_DOUBLE, coeff_0_2,
+                                          G_TYPE_DOUBLE, coeff_1_0,
+                                          G_TYPE_DOUBLE, coeff_1_1,
+                                          G_TYPE_DOUBLE, coeff_1_2,
+                                          G_TYPE_DOUBLE, coeff_2_0,
+                                          G_TYPE_DOUBLE, coeff_2_1,
+                                          G_TYPE_DOUBLE, coeff_2_2,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-item-transform-matrix",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-item-transform-matrix",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    ret_item = gimp_item_new_by_id (gimp_value_get_item_id (gimp_value_array_index (return_vals, 1)));
+
+  gimp_value_array_unref (return_vals);
+
+  return ret_item;
+}
+
+/**
+ * _gimp_item_transform_matrix: (skip)
  * @item_ID: The affected item.
  * @coeff_0_0: coefficient (0,0) of the transformation matrix.
  * @coeff_0_1: coefficient (0,1) of the transformation matrix.
@@ -740,16 +1492,16 @@ gimp_item_transform_2d (gint32  item_ID,
  * Since: 2.8
  **/
 gint32
-gimp_item_transform_matrix (gint32  item_ID,
-                            gdouble coeff_0_0,
-                            gdouble coeff_0_1,
-                            gdouble coeff_0_2,
-                            gdouble coeff_1_0,
-                            gdouble coeff_1_1,
-                            gdouble coeff_1_2,
-                            gdouble coeff_2_0,
-                            gdouble coeff_2_1,
-                            gdouble coeff_2_2)
+_gimp_item_transform_matrix (gint32  item_ID,
+                             gdouble coeff_0_0,
+                             gdouble coeff_0_1,
+                             gdouble coeff_0_2,
+                             gdouble coeff_1_0,
+                             gdouble coeff_1_1,
+                             gdouble coeff_1_2,
+                             gdouble coeff_2_0,
+                             gdouble coeff_2_1,
+                             gdouble coeff_2_2)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpitemtransform_pdb.h b/libgimp/gimpitemtransform_pdb.h
index 0d89bf58c2..b379c69a94 100644
--- a/libgimp/gimpitemtransform_pdb.h
+++ b/libgimp/gimpitemtransform_pdb.h
@@ -32,70 +32,80 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gint32 gimp_item_transform_translate     (gint32              item_ID,
-                                          gdouble             off_x,
-                                          gdouble             off_y);
-gint32 gimp_item_transform_flip_simple   (gint32              item_ID,
-                                          GimpOrientationType flip_type,
-                                          gboolean            auto_center,
-                                          gdouble             axis);
-gint32 gimp_item_transform_flip          (gint32              item_ID,
-                                          gdouble             x0,
-                                          gdouble             y0,
-                                          gdouble             x1,
-                                          gdouble             y1);
-gint32 gimp_item_transform_perspective   (gint32              item_ID,
-                                          gdouble             x0,
-                                          gdouble             y0,
-                                          gdouble             x1,
-                                          gdouble             y1,
-                                          gdouble             x2,
-                                          gdouble             y2,
-                                          gdouble             x3,
-                                          gdouble             y3);
-gint32 gimp_item_transform_rotate_simple (gint32              item_ID,
-                                          GimpRotationType    rotate_type,
-                                          gboolean            auto_center,
-                                          gdouble             center_x,
-                                          gdouble             center_y);
-gint32 gimp_item_transform_rotate        (gint32              item_ID,
-                                          gdouble             angle,
-                                          gboolean            auto_center,
-                                          gdouble             center_x,
-                                          gdouble             center_y);
-gint32 gimp_item_transform_scale         (gint32              item_ID,
-                                          gdouble             x0,
-                                          gdouble             y0,
-                                          gdouble             x1,
-                                          gdouble             y1);
-gint32 gimp_item_transform_shear         (gint32              item_ID,
-                                          GimpOrientationType shear_type,
-                                          gdouble             magnitude);
-gint32 gimp_item_transform_2d            (gint32              item_ID,
-                                          gdouble             source_x,
-                                          gdouble             source_y,
-                                          gdouble             scale_x,
-                                          gdouble             scale_y,
-                                          gdouble             angle,
-                                          gdouble             dest_x,
-                                          gdouble             dest_y);
-gint32 gimp_item_transform_matrix        (gint32              item_ID,
-                                          gdouble             coeff_0_0,
-                                          gdouble             coeff_0_1,
-                                          gdouble             coeff_0_2,
-                                          gdouble             coeff_1_0,
-                                          gdouble             coeff_1_1,
-                                          gdouble             coeff_1_2,
-                                          gdouble             coeff_2_0,
-                                          gdouble             coeff_2_1,
-                                          gdouble             coeff_2_2);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
+GimpItem* gimp_item_transform_translate     (GimpItem            *item,
+                                             gdouble              off_x,
+                                             gdouble              off_y);
+GimpItem* gimp_item_transform_flip_simple   (GimpItem            *item,
+                                             GimpOrientationType  flip_type,
+                                             gboolean             auto_center,
+                                             gdouble              axis);
+GimpItem* gimp_item_transform_flip          (GimpItem            *item,
+                                             gdouble              x0,
+                                             gdouble              y0,
+                                             gdouble              x1,
+                                             gdouble              y1);
+GimpItem* gimp_item_transform_perspective   (GimpItem            *item,
+                                             gdouble              x0,
+                                             gdouble              y0,
+                                             gdouble              x1,
+                                             gdouble              y1,
+                                             gdouble              x2,
+                                             gdouble              y2,
+                                             gdouble              x3,
+                                             gdouble              y3);
+GimpItem* gimp_item_transform_rotate_simple (GimpItem            *item,
+                                             GimpRotationType     rotate_type,
+                                             gboolean             auto_center,
+                                             gdouble              center_x,
+                                             gdouble              center_y);
+GimpItem* gimp_item_transform_rotate        (GimpItem            *item,
+                                             gdouble              angle,
+                                             gboolean             auto_center,
+                                             gdouble              center_x,
+                                             gdouble              center_y);
+GimpItem* gimp_item_transform_scale         (GimpItem            *item,
+                                             gdouble              x0,
+                                             gdouble              y0,
+                                             gdouble              x1,
+                                             gdouble              y1);
+GimpItem* gimp_item_transform_shear         (GimpItem            *item,
+                                             GimpOrientationType  shear_type,
+                                             gdouble              magnitude);
+GimpItem* gimp_item_transform_2d            (GimpItem            *item,
+                                             gdouble              source_x,
+                                             gdouble              source_y,
+                                             gdouble              scale_x,
+                                             gdouble              scale_y,
+                                             gdouble              angle,
+                                             gdouble              dest_x,
+                                             gdouble              dest_y);
+GimpItem* gimp_item_transform_matrix        (GimpItem            *item,
+                                             gdouble              coeff_0_0,
+                                             gdouble              coeff_0_1,
+                                             gdouble              coeff_0_2,
+                                             gdouble              coeff_1_0,
+                                             gdouble              coeff_1_1,
+                                             gdouble              coeff_1_2,
+                                             gdouble              coeff_2_0,
+                                             gdouble              coeff_2_1,
+                                             gdouble              coeff_2_2);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_item_transform_translate _gimp_item_transform_translate
+#define gimp_item_transform_flip_simple _gimp_item_transform_flip_simple
+#define gimp_item_transform_flip _gimp_item_transform_flip
+#define gimp_item_transform_perspective _gimp_item_transform_perspective
+#define gimp_item_transform_rotate_simple _gimp_item_transform_rotate_simple
+#define gimp_item_transform_rotate _gimp_item_transform_rotate
+#define gimp_item_transform_scale _gimp_item_transform_scale
+#define gimp_item_transform_shear _gimp_item_transform_shear
+#define gimp_item_transform_2d _gimp_item_transform_2d
+#define gimp_item_transform_matrix _gimp_item_transform_matrix
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -104,7 +114,63 @@ gint32 gimp_item_transform_matrix        (gint32              item_ID,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gint32 _gimp_item_transform_translate     (gint32              item_ID,
+                                           gdouble             off_x,
+                                           gdouble             off_y);
+gint32 _gimp_item_transform_flip_simple   (gint32              item_ID,
+                                           GimpOrientationType flip_type,
+                                           gboolean            auto_center,
+                                           gdouble             axis);
+gint32 _gimp_item_transform_flip          (gint32              item_ID,
+                                           gdouble             x0,
+                                           gdouble             y0,
+                                           gdouble             x1,
+                                           gdouble             y1);
+gint32 _gimp_item_transform_perspective   (gint32              item_ID,
+                                           gdouble             x0,
+                                           gdouble             y0,
+                                           gdouble             x1,
+                                           gdouble             y1,
+                                           gdouble             x2,
+                                           gdouble             y2,
+                                           gdouble             x3,
+                                           gdouble             y3);
+gint32 _gimp_item_transform_rotate_simple (gint32              item_ID,
+                                           GimpRotationType    rotate_type,
+                                           gboolean            auto_center,
+                                           gdouble             center_x,
+                                           gdouble             center_y);
+gint32 _gimp_item_transform_rotate        (gint32              item_ID,
+                                           gdouble             angle,
+                                           gboolean            auto_center,
+                                           gdouble             center_x,
+                                           gdouble             center_y);
+gint32 _gimp_item_transform_scale         (gint32              item_ID,
+                                           gdouble             x0,
+                                           gdouble             y0,
+                                           gdouble             x1,
+                                           gdouble             y1);
+gint32 _gimp_item_transform_shear         (gint32              item_ID,
+                                           GimpOrientationType shear_type,
+                                           gdouble             magnitude);
+gint32 _gimp_item_transform_2d            (gint32              item_ID,
+                                           gdouble             source_x,
+                                           gdouble             source_y,
+                                           gdouble             scale_x,
+                                           gdouble             scale_y,
+                                           gdouble             angle,
+                                           gdouble             dest_x,
+                                           gdouble             dest_y);
+gint32 _gimp_item_transform_matrix        (gint32              item_ID,
+                                           gdouble             coeff_0_0,
+                                           gdouble             coeff_0_1,
+                                           gdouble             coeff_0_2,
+                                           gdouble             coeff_1_0,
+                                           gdouble             coeff_1_1,
+                                           gdouble             coeff_1_2,
+                                           gdouble             coeff_2_0,
+                                           gdouble             coeff_2_1,
+                                           gdouble             coeff_2_2);
 
 
 G_END_DECLS
diff --git a/libgimp/gimplayer.c b/libgimp/gimplayer.c
index dcff5daf57..d019cb76a2 100644
--- a/libgimp/gimplayer.c
+++ b/libgimp/gimplayer.c
@@ -25,6 +25,25 @@
 #include "gimp.h"
 
 
+G_DEFINE_TYPE (GimpLayer, gimp_layer, GIMP_TYPE_DRAWABLE)
+
+#define parent_class gimp_layer_parent_class
+
+
+static void
+gimp_layer_class_init (GimpLayerClass *klass)
+{
+}
+
+static void
+gimp_layer_init (GimpLayer *layer)
+{
+}
+
+
+/* Public API. */
+
+
 /**
  * gimp_layer_new:
  * @image:   The image to which to add the layer.
diff --git a/libgimp/gimplayer.h b/libgimp/gimplayer.h
index f6895b94a7..fc4dfd530d 100644
--- a/libgimp/gimplayer.h
+++ b/libgimp/gimplayer.h
@@ -29,6 +29,39 @@ G_BEGIN_DECLS
 
 /* For information look into the C source or the html documentation */
 
+#define GIMP_TYPE_LAYER            (gimp_layer_get_type ())
+#define GIMP_LAYER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
+#define GIMP_LAYER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
+#define GIMP_IS_LAYER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LAYER))
+#define GIMP_IS_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
+#define GIMP_LAYER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_LAYER, GimpLayerClass))
+
+
+typedef struct _GimpLayerClass   GimpLayerClass;
+typedef struct _GimpLayerPrivate GimpLayerPrivate;
+
+struct _GimpLayer
+{
+  GimpDrawable      parent_instance;
+};
+
+struct _GimpLayerClass
+{
+  GimpDrawableClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gimp_reserved1) (void);
+  void (*_gimp_reserved2) (void);
+  void (*_gimp_reserved3) (void);
+  void (*_gimp_reserved4) (void);
+  void (*_gimp_reserved5) (void);
+  void (*_gimp_reserved6) (void);
+  void (*_gimp_reserved7) (void);
+  void (*_gimp_reserved8) (void);
+  void (*_gimp_reserved9) (void);
+};
+
+GType    gimp_layer_get_type           (void) G_GNUC_CONST;
 
 gint32   gimp_layer_copy               (gint32           layer_ID);
 
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 01babe8e57..e0cb6aa97e 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -53,9 +53,9 @@
  * command. Other attributes such as layer mask modes, and offsets
  * should be set with explicit procedure calls.
  *
- * Returns: The newly created layer.
+ * Returns: (transfer full): The newly created layer.
  **/
-gint32
+GimpLayer *
 _gimp_layer_new (GimpImage     *image,
                  gint           width,
                  gint           height,
@@ -67,7 +67,7 @@ _gimp_layer_new (GimpImage     *image,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -89,11 +89,11 @@ _gimp_layer_new (GimpImage     *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -172,11 +172,11 @@ __gimp_layer_new (gint32         image_ID,
  * 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.
+ * Returns: (transfer full): The newly created layer.
  *
  * Since: 2.6
  **/
-gint32
+GimpLayer *
 gimp_layer_new_from_visible (GimpImage   *image,
                              GimpImage   *dest_image,
                              const gchar *name)
@@ -184,7 +184,7 @@ gimp_layer_new_from_visible (GimpImage   *image,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -202,11 +202,11 @@ gimp_layer_new_from_visible (GimpImage   *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -262,7 +262,7 @@ _gimp_layer_new_from_visible (gint32       image_ID,
 
 /**
  * gimp_layer_new_from_drawable:
- * @drawable_ID: The source drawable from where the new layer is copied.
+ * @drawable: The source drawable from where the new layer is copied.
  * @dest_image: The destination image to which to add the layer.
  *
  * Create a new layer by copying an existing drawable.
@@ -273,19 +273,19 @@ _gimp_layer_new_from_visible (gint32       image_ID,
  * 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.
+ * Returns: (transfer full): The newly copied layer.
  **/
-gint32
-gimp_layer_new_from_drawable (gint32     drawable_ID,
-                              GimpImage *dest_image)
+GimpLayer *
+gimp_layer_new_from_drawable (GimpDrawable *drawable,
+                              GimpImage    *dest_image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_copy_ID = -1;
+  GimpLayer *layer_copy = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (dest_image),
                                           G_TYPE_NONE);
 
@@ -299,11 +299,11 @@ gimp_layer_new_from_drawable (gint32     drawable_ID,
   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));
+    layer_copy = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_copy_ID;
+  return layer_copy;
 }
 
 /**
@@ -366,17 +366,17 @@ _gimp_layer_new_from_drawable (gint32 drawable_ID,
  * gimp_image_reorder_item(), gimp_item_get_parent(),
  * gimp_item_get_children(), gimp_item_is_group().
  *
- * Returns: The newly created layer group.
+ * Returns: (transfer full): The newly created layer group.
  *
  * Since: 2.8
  **/
-gint32
+GimpLayer *
 gimp_layer_group_new (GimpImage *image)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_group_ID = -1;
+  GimpLayer *layer_group = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -392,11 +392,11 @@ gimp_layer_group_new (GimpImage *image)
   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));
+    layer_group = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_group_ID;
+  return layer_group;
 }
 
 /**
@@ -448,6 +448,53 @@ _gimp_layer_group_new (gint32 image_ID)
 
 /**
  * _gimp_layer_copy:
+ * @layer: The layer to copy.
+ * @add_alpha: Add an alpha channel to the copied layer.
+ *
+ * Copy a layer.
+ *
+ * This procedure copies the specified layer and returns the copy. The
+ * newly copied layer is for use within the original layer's image. It
+ * should not be subsequently added to any other image. The copied
+ * layer can optionally have an added alpha channel. This is useful if
+ * the background layer in an image is being copied and added to the
+ * same image.
+ *
+ * Returns: (transfer full): The newly copied layer.
+ **/
+GimpLayer *
+_gimp_layer_copy (GimpLayer *layer,
+                  gboolean   add_alpha)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayer *layer_copy = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, add_alpha,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-copy",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-copy",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer_copy = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer_copy;
+}
+
+/**
+ * __gimp_layer_copy: (skip)
  * @layer_ID: The layer to copy.
  * @add_alpha: Add an alpha channel to the copied layer.
  *
@@ -463,8 +510,8 @@ _gimp_layer_group_new (gint32 image_ID)
  * Returns: The newly copied layer.
  **/
 gint32
-_gimp_layer_copy (gint32   layer_ID,
-                  gboolean add_alpha)
+__gimp_layer_copy (gint32   layer_ID,
+                   gboolean add_alpha)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -495,6 +542,48 @@ _gimp_layer_copy (gint32   layer_ID,
 
 /**
  * gimp_layer_add_alpha:
+ * @layer: The layer.
+ *
+ * Add an alpha channel to the layer if it doesn't already have one.
+ *
+ * This procedure adds an additional component to the specified layer
+ * if it does not already possess an alpha channel. An alpha channel
+ * makes it possible to clear and erase to transparency, instead of the
+ * background color. This transforms layers of type RGB to RGBA, GRAY
+ * to GRAYA, and INDEXED to INDEXEDA.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_add_alpha (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-add-alpha",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-add-alpha",
+                                            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_layer_add_alpha: (skip)
  * @layer_ID: The layer.
  *
  * Add an alpha channel to the layer if it doesn't already have one.
@@ -508,7 +597,7 @@ _gimp_layer_copy (gint32   layer_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_add_alpha (gint32 layer_ID)
+_gimp_layer_add_alpha (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -537,6 +626,49 @@ gimp_layer_add_alpha (gint32 layer_ID)
 
 /**
  * gimp_layer_flatten:
+ * @layer: The layer.
+ *
+ * Remove the alpha channel from the layer if it has one.
+ *
+ * This procedure removes the alpha channel from a layer, blending all
+ * (partially) transparent pixels in the layer against the background
+ * color. This transforms layers of type RGBA to RGB, GRAYA to GRAY,
+ * and INDEXEDA to INDEXED.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_layer_flatten (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-flatten",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-flatten",
+                                            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_layer_flatten: (skip)
  * @layer_ID: The layer.
  *
  * Remove the alpha channel from the layer if it has one.
@@ -551,7 +683,7 @@ gimp_layer_add_alpha (gint32 layer_ID)
  * Since: 2.4
  **/
 gboolean
-gimp_layer_flatten (gint32 layer_ID)
+_gimp_layer_flatten (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -580,7 +712,7 @@ gimp_layer_flatten (gint32 layer_ID)
 
 /**
  * gimp_layer_scale:
- * @layer_ID: The layer.
+ * @layer: The layer.
  * @new_width: New layer width.
  * @new_height: New layer height.
  * @local_origin: Use a local origin (as opposed to the image origin).
@@ -597,10 +729,10 @@ gimp_layer_flatten (gint32 layer_ID)
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_scale (gint32   layer_ID,
-                  gint     new_width,
-                  gint     new_height,
-                  gboolean local_origin)
+gimp_layer_scale (GimpLayer *layer,
+                  gint       new_width,
+                  gint       new_height,
+                  gboolean   local_origin)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -608,7 +740,7 @@ gimp_layer_scale (gint32   layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_INT, new_width,
                                           G_TYPE_INT, new_height,
                                           G_TYPE_BOOLEAN, local_origin,
@@ -631,28 +763,28 @@ gimp_layer_scale (gint32   layer_ID,
 }
 
 /**
- * gimp_layer_resize:
+ * _gimp_layer_scale: (skip)
  * @layer_ID: The layer.
  * @new_width: New layer width.
  * @new_height: New layer height.
- * @offx: x offset between upper left corner of old and new layers: (old - new).
- * @offy: y offset between upper left corner of old and new layers: (old - new).
+ * @local_origin: Use a local origin (as opposed to the image origin).
  *
- * Resize the layer to the specified extents.
+ * Scale the layer using the default interpolation method.
  *
- * This procedure resizes the layer so that its new width and height
- * are equal to the supplied parameters. Offsets are also provided
- * which describe the position of the previous layer's content. This
- * operation only works if the layer has been added to an image.
+ * This procedure scales the layer so that its new width and height are
+ * equal to the supplied parameters. The 'local-origin' parameter
+ * specifies whether to scale from the center of the layer, or from the
+ * image origin. This operation only works if the layer has been added
+ * to an image. The interpolation method used can be set with
+ * gimp_context_set_interpolation().
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_resize (gint32 layer_ID,
-                   gint   new_width,
-                   gint   new_height,
-                   gint   offx,
-                   gint   offy)
+_gimp_layer_scale (gint32   layer_ID,
+                   gint     new_width,
+                   gint     new_height,
+                   gboolean local_origin)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -663,16 +795,15 @@ gimp_layer_resize (gint32 layer_ID,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_INT, new_width,
                                           G_TYPE_INT, new_height,
-                                          G_TYPE_INT, offx,
-                                          G_TYPE_INT, offy,
+                                          G_TYPE_BOOLEAN, local_origin,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-resize",
+                                                "gimp-layer-scale",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-resize",
+    return_vals = gimp_run_procedure_array ("gimp-layer-scale",
                                             args);
   gimp_value_array_unref (args);
 
@@ -684,18 +815,28 @@ gimp_layer_resize (gint32 layer_ID,
 }
 
 /**
- * gimp_layer_resize_to_image_size:
- * @layer_ID: The layer to resize.
+ * gimp_layer_resize:
+ * @layer: The layer.
+ * @new_width: New layer width.
+ * @new_height: New layer height.
+ * @offx: x offset between upper left corner of old and new layers: (old - new).
+ * @offy: y offset between upper left corner of old and new layers: (old - new).
  *
- * Resize a layer to the image size.
+ * Resize the layer to the specified extents.
  *
- * This procedure resizes the layer so that it's new width and height
- * are equal to the width and height of its image container.
+ * This procedure resizes the layer so that its new width and height
+ * are equal to the supplied parameters. Offsets are also provided
+ * which describe the position of the previous layer's content. This
+ * operation only works if the layer has been added to an image.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_resize_to_image_size (gint32 layer_ID)
+gimp_layer_resize (GimpLayer *layer,
+                   gint       new_width,
+                   gint       new_height,
+                   gint       offx,
+                   gint       offy)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -703,15 +844,19 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          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-layer-resize-to-image-size",
+                                                "gimp-layer-resize",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-resize-to-image-size",
+    return_vals = gimp_run_procedure_array ("gimp-layer-resize",
                                             args);
   gimp_value_array_unref (args);
 
@@ -723,23 +868,28 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
 }
 
 /**
- * gimp_layer_set_offsets:
+ * _gimp_layer_resize: (skip)
  * @layer_ID: The layer.
- * @offx: Offset in x direction.
- * @offy: Offset in y direction.
+ * @new_width: New layer width.
+ * @new_height: New layer height.
+ * @offx: x offset between upper left corner of old and new layers: (old - new).
+ * @offy: y offset between upper left corner of old and new layers: (old - new).
  *
- * Set the layer offsets.
+ * Resize the layer to the specified extents.
  *
- * This procedure sets the offsets for the specified layer. The offsets
- * are relative to the image origin and can be any values. This
- * operation is valid only on layers which have been added to an image.
+ * This procedure resizes the layer so that its new width and height
+ * are equal to the supplied parameters. Offsets are also provided
+ * which describe the position of the previous layer's content. This
+ * operation only works if the layer has been added to an image.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_set_offsets (gint32 layer_ID,
-                        gint   offx,
-                        gint   offy)
+_gimp_layer_resize (gint32 layer_ID,
+                    gint   new_width,
+                    gint   new_height,
+                    gint   offx,
+                    gint   offy)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -748,16 +898,18 @@ gimp_layer_set_offsets (gint32 layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_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-layer-set-offsets",
+                                                "gimp-layer-resize",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-offsets",
+    return_vals = gimp_run_procedure_array ("gimp-layer-resize",
                                             args);
   gimp_value_array_unref (args);
 
@@ -769,84 +921,1287 @@ gimp_layer_set_offsets (gint32 layer_ID,
 }
 
 /**
- * gimp_layer_create_mask:
- * @layer_ID: The layer to which to add the mask.
- * @mask_type: The type of mask.
- *
- * Create a layer mask for the specified layer.
- *
- * This procedure creates a layer mask for the specified layer.
- * Layer masks serve as an additional alpha channel for a layer.
- * Different types of masks are allowed for initialisation:
- * - white mask (leaves the layer fully visible);
- * - black mask (gives the layer complete transparency);
- * - the layer's alpha channel (either a copy, or a transfer, which
- * leaves the layer fully visible, but which may be more useful than a
- * white mask);
- * - the current selection;
- * - a grayscale copy of the layer;
- * - or a copy of the active channel.
+ * gimp_layer_resize_to_image_size:
+ * @layer: The layer to resize.
  *
- * The layer mask still needs to be added to the layer. This can be
- * done with a call to gimp_layer_add_mask().
+ * Resize a layer to the image size.
  *
- * gimp_layer_create_mask() will fail if there are no active channels
- * on the image, when called with 'ADD-CHANNEL-MASK'. It will return a
- * black mask when called with 'ADD-ALPHA-MASK' or
- * 'ADD-ALPHA-TRANSFER-MASK' on a layer with no alpha channels, or with
- * 'ADD-SELECTION-MASK' when there is no selection on the image.
+ * This procedure resizes the layer so that it's new width and height
+ * are equal to the width and height of its image container.
  *
- * Returns: The newly created mask.
+ * Returns: TRUE on success.
  **/
-gint32
-gimp_layer_create_mask (gint32          layer_ID,
-                        GimpAddMaskType mask_type)
+gboolean
+gimp_layer_resize_to_image_size (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 mask_ID = -1;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_ADD_MASK_TYPE, mask_type,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-create-mask",
+                                                "gimp-layer-resize-to-image-size",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-create-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-resize-to-image-size",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    mask_ID = gimp_value_get_layer_mask_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 mask_ID;
+  return success;
 }
 
 /**
- * gimp_layer_get_mask:
- * @layer_ID: The layer.
+ * _gimp_layer_resize_to_image_size: (skip)
+ * @layer_ID: The layer to resize.
  *
- * Get the specified layer's mask if it exists.
+ * Resize a layer to the image size.
+ *
+ * This procedure resizes the layer so that it's new width and height
+ * are equal to the width and height of its image container.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_resize_to_image_size (gint32 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_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-resize-to-image-size",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-resize-to-image-size",
+                                            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_layer_set_offsets:
+ * @layer: The layer.
+ * @offx: Offset in x direction.
+ * @offy: Offset in y direction.
+ *
+ * Set the layer offsets.
+ *
+ * This procedure sets the offsets for the specified layer. The offsets
+ * are relative to the image origin and can be any values. This
+ * operation is valid only on layers which have been added to an image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_set_offsets (GimpLayer *layer,
+                        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_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-offsets",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-offsets",
+                                            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_layer_set_offsets: (skip)
+ * @layer_ID: The layer.
+ * @offx: Offset in x direction.
+ * @offy: Offset in y direction.
+ *
+ * Set the layer offsets.
+ *
+ * This procedure sets the offsets for the specified layer. The offsets
+ * are relative to the image origin and can be any values. This
+ * operation is valid only on layers which have been added to an image.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_set_offsets (gint32 layer_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_LAYER_ID, layer_ID,
+                                          G_TYPE_INT, offx,
+                                          G_TYPE_INT, offy,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-offsets",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-offsets",
+                                            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_layer_create_mask:
+ * @layer: The layer to which to add the mask.
+ * @mask_type: The type of mask.
+ *
+ * Create a layer mask for the specified layer.
+ *
+ * This procedure creates a layer mask for the specified layer.
+ * Layer masks serve as an additional alpha channel for a layer.
+ * Different types of masks are allowed for initialisation:
+ * - white mask (leaves the layer fully visible);
+ * - black mask (gives the layer complete transparency);
+ * - the layer's alpha channel (either a copy, or a transfer, which
+ * leaves the layer fully visible, but which may be more useful than a
+ * white mask);
+ * - the current selection;
+ * - a grayscale copy of the layer;
+ * - or a copy of the active channel.
+ *
+ * The layer mask still needs to be added to the layer. This can be
+ * done with a call to gimp_layer_add_mask().
+ *
+ * gimp_layer_create_mask() will fail if there are no active channels
+ * on the image, when called with 'ADD-CHANNEL-MASK'. It will return a
+ * black mask when called with 'ADD-ALPHA-MASK' or
+ * 'ADD-ALPHA-TRANSFER-MASK' on a layer with no alpha channels, or with
+ * 'ADD-SELECTION-MASK' when there is no selection on the image.
+ *
+ * Returns: The newly created mask.
+ **/
+gint32
+gimp_layer_create_mask (GimpLayer       *layer,
+                        GimpAddMaskType  mask_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 mask_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_ADD_MASK_TYPE, mask_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-create-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-create-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return mask_ID;
+}
+
+/**
+ * _gimp_layer_create_mask: (skip)
+ * @layer_ID: The layer to which to add the mask.
+ * @mask_type: The type of mask.
+ *
+ * Create a layer mask for the specified layer.
+ *
+ * This procedure creates a layer mask for the specified layer.
+ * Layer masks serve as an additional alpha channel for a layer.
+ * Different types of masks are allowed for initialisation:
+ * - white mask (leaves the layer fully visible);
+ * - black mask (gives the layer complete transparency);
+ * - the layer's alpha channel (either a copy, or a transfer, which
+ * leaves the layer fully visible, but which may be more useful than a
+ * white mask);
+ * - the current selection;
+ * - a grayscale copy of the layer;
+ * - or a copy of the active channel.
+ *
+ * The layer mask still needs to be added to the layer. This can be
+ * done with a call to gimp_layer_add_mask().
+ *
+ * gimp_layer_create_mask() will fail if there are no active channels
+ * on the image, when called with 'ADD-CHANNEL-MASK'. It will return a
+ * black mask when called with 'ADD-ALPHA-MASK' or
+ * 'ADD-ALPHA-TRANSFER-MASK' on a layer with no alpha channels, or with
+ * 'ADD-SELECTION-MASK' when there is no selection on the image.
+ *
+ * Returns: The newly created mask.
+ **/
+gint32
+_gimp_layer_create_mask (gint32          layer_ID,
+                         GimpAddMaskType mask_type)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 mask_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_ADD_MASK_TYPE, mask_type,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-create-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-create-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return mask_ID;
+}
+
+/**
+ * gimp_layer_get_mask:
+ * @layer: The layer.
+ *
+ * Get the specified layer's mask if it exists.
+ *
+ * This procedure returns the specified layer's mask, or -1 if none
+ * exists.
+ *
+ * Returns: The layer mask.
+ **/
+gint32
+gimp_layer_get_mask (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 mask_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return mask_ID;
+}
+
+/**
+ * _gimp_layer_get_mask: (skip)
+ * @layer_ID: The layer.
+ *
+ * Get the specified layer's mask if it exists.
+ *
+ * This procedure returns the specified layer's mask, or -1 if none
+ * exists.
+ *
+ * Returns: The layer mask.
+ **/
+gint32
+_gimp_layer_get_mask (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 mask_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return mask_ID;
+}
+
+/**
+ * gimp_layer_from_mask:
+ * @mask_ID: Mask for which to return the layer.
+ *
+ * Get the specified mask's layer.
+ *
+ * This procedure returns the specified mask's layer , or -1 if none
+ * exists.
+ *
+ * Returns: (transfer full): The mask's layer.
+ *
+ * Since: 2.2
+ **/
+GimpLayer *
+gimp_layer_from_mask (gint32 mask_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayer *layer = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-from-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-from-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer;
+}
+
+/**
+ * _gimp_layer_from_mask: (skip)
+ * @mask_ID: Mask for which to return the layer.
+ *
+ * Get the specified mask's layer.
+ *
+ * This procedure returns the specified mask's layer , or -1 if none
+ * exists.
+ *
+ * Returns: The mask's layer.
+ *
+ * Since: 2.2
+ **/
+gint32
+_gimp_layer_from_mask (gint32 mask_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gint32 layer_ID = -1;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-from-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-from-mask",
+                                            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_add_mask:
+ * @layer: The layer to receive the mask.
+ * @mask_ID: The mask to add to the layer.
+ *
+ * Add a layer mask to the specified layer.
+ *
+ * This procedure adds a layer mask to the specified layer. Layer masks
+ * serve as an additional alpha channel for a layer. This procedure
+ * will fail if a number of prerequisites aren't met. The layer cannot
+ * already have a layer mask. The specified mask must exist and have
+ * the same dimensions as the layer. The layer must have been created
+ * for use with the specified image and the mask must have been created
+ * with the procedure 'gimp-layer-create-mask'.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_add_mask (GimpLayer *layer,
+                     gint32     mask_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-add-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-add-mask",
+                                            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_layer_add_mask: (skip)
+ * @layer_ID: The layer to receive the mask.
+ * @mask_ID: The mask to add to the layer.
+ *
+ * Add a layer mask to the specified layer.
+ *
+ * This procedure adds a layer mask to the specified layer. Layer masks
+ * serve as an additional alpha channel for a layer. This procedure
+ * will fail if a number of prerequisites aren't met. The layer cannot
+ * already have a layer mask. The specified mask must exist and have
+ * the same dimensions as the layer. The layer must have been created
+ * for use with the specified image and the mask must have been created
+ * with the procedure 'gimp-layer-create-mask'.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_add_mask (gint32 layer_ID,
+                      gint32 mask_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-add-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-add-mask",
+                                            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_layer_remove_mask:
+ * @layer: The layer from which to remove mask.
+ * @mode: Removal mode.
+ *
+ * Remove the specified layer mask from the layer.
+ *
+ * This procedure removes the specified layer mask from the layer. If
+ * the mask doesn't exist, an error is returned.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_remove_mask (GimpLayer         *layer,
+                        GimpMaskApplyMode  mode)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_MASK_APPLY_MODE, mode,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-remove-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-remove-mask",
+                                            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_layer_remove_mask: (skip)
+ * @layer_ID: The layer from which to remove mask.
+ * @mode: Removal mode.
+ *
+ * Remove the specified layer mask from the layer.
+ *
+ * This procedure removes the specified layer mask from the layer. If
+ * the mask doesn't exist, an error is returned.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_remove_mask (gint32            layer_ID,
+                         GimpMaskApplyMode mode)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_MASK_APPLY_MODE, mode,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-remove-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-remove-mask",
+                                            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_layer_is_floating_sel:
+ * @layer: The layer.
+ *
+ * Is the specified layer a floating selection?
+ *
+ * This procedure returns whether the layer is a floating selection.
+ * Floating selections are special cases of layers which are attached
+ * to a specific drawable.
+ *
+ * Returns: TRUE if the layer is a floating selection.
+ **/
+gboolean
+gimp_layer_is_floating_sel (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_floating_sel = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-is-floating-sel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-is-floating-sel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_floating_sel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_floating_sel;
+}
+
+/**
+ * _gimp_layer_is_floating_sel: (skip)
+ * @layer_ID: The layer.
+ *
+ * Is the specified layer a floating selection?
+ *
+ * This procedure returns whether the layer is a floating selection.
+ * Floating selections are special cases of layers which are attached
+ * to a specific drawable.
+ *
+ * Returns: TRUE if the layer is a floating selection.
+ **/
+gboolean
+_gimp_layer_is_floating_sel (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean is_floating_sel = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-is-floating-sel",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-is-floating-sel",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    is_floating_sel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return is_floating_sel;
+}
+
+/**
+ * gimp_layer_get_lock_alpha:
+ * @layer: The layer.
+ *
+ * Get the lock alpha channel setting of the specified layer.
+ *
+ * This procedure returns the specified layer's lock alpha channel
+ * setting.
+ *
+ * Returns: The layer's lock alpha channel setting.
+ **/
+gboolean
+gimp_layer_get_lock_alpha (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean lock_alpha = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-lock-alpha",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-lock-alpha",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    lock_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return lock_alpha;
+}
+
+/**
+ * _gimp_layer_get_lock_alpha: (skip)
+ * @layer_ID: The layer.
+ *
+ * Get the lock alpha channel setting of the specified layer.
+ *
+ * This procedure returns the specified layer's lock alpha channel
+ * setting.
+ *
+ * Returns: The layer's lock alpha channel setting.
+ **/
+gboolean
+_gimp_layer_get_lock_alpha (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean lock_alpha = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-lock-alpha",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-lock-alpha",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    lock_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return lock_alpha;
+}
+
+/**
+ * gimp_layer_set_lock_alpha:
+ * @layer: The layer.
+ * @lock_alpha: The new layer's lock alpha channel setting.
+ *
+ * Set the lock alpha channel setting of the specified layer.
+ *
+ * This procedure sets the specified layer's lock alpha channel
+ * setting.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_set_lock_alpha (GimpLayer *layer,
+                           gboolean   lock_alpha)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, lock_alpha,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-lock-alpha",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-lock-alpha",
+                                            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_layer_set_lock_alpha: (skip)
+ * @layer_ID: The layer.
+ * @lock_alpha: The new layer's lock alpha channel setting.
+ *
+ * Set the lock alpha channel setting of the specified layer.
+ *
+ * This procedure sets the specified layer's lock alpha channel
+ * setting.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_set_lock_alpha (gint32   layer_ID,
+                            gboolean lock_alpha)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, lock_alpha,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-lock-alpha",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-lock-alpha",
+                                            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_layer_get_apply_mask:
+ * @layer: The layer.
+ *
+ * Get the apply mask setting of the specified layer.
+ *
+ * This procedure returns the specified layer's apply mask setting. If
+ * the value is TRUE, then the layer mask for this layer is currently
+ * being composited with the layer's alpha channel.
+ *
+ * Returns: The layer's apply mask setting.
+ **/
+gboolean
+gimp_layer_get_apply_mask (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean apply_mask = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-apply-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-apply-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    apply_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return apply_mask;
+}
+
+/**
+ * _gimp_layer_get_apply_mask: (skip)
+ * @layer_ID: The layer.
+ *
+ * Get the apply mask setting of the specified layer.
+ *
+ * This procedure returns the specified layer's apply mask setting. If
+ * the value is TRUE, then the layer mask for this layer is currently
+ * being composited with the layer's alpha channel.
+ *
+ * Returns: The layer's apply mask setting.
+ **/
+gboolean
+_gimp_layer_get_apply_mask (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean apply_mask = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-apply-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-apply-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    apply_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return apply_mask;
+}
+
+/**
+ * gimp_layer_set_apply_mask:
+ * @layer: The layer.
+ * @apply_mask: The new layer's apply mask setting.
+ *
+ * Set the apply mask setting of the specified layer.
+ *
+ * This procedure sets the specified layer's apply mask setting. This
+ * controls whether the layer's mask is currently affecting the alpha
+ * channel. If there is no layer mask, this function will return an
+ * error.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_set_apply_mask (GimpLayer *layer,
+                           gboolean   apply_mask)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, apply_mask,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-apply-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-apply-mask",
+                                            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_layer_set_apply_mask: (skip)
+ * @layer_ID: The layer.
+ * @apply_mask: The new layer's apply mask setting.
+ *
+ * Set the apply mask setting of the specified layer.
+ *
+ * This procedure sets the specified layer's apply mask setting. This
+ * controls whether the layer's mask is currently affecting the alpha
+ * channel. If there is no layer mask, this function will return an
+ * error.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_set_apply_mask (gint32   layer_ID,
+                            gboolean apply_mask)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, apply_mask,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-apply-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-apply-mask",
+                                            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_layer_get_show_mask:
+ * @layer: The layer.
+ *
+ * Get the show mask setting of the specified layer.
+ *
+ * This procedure returns the specified layer's show mask setting. This
+ * controls whether the layer or its mask is visible. TRUE indicates
+ * that the mask should be visible. If the layer has no mask, then this
+ * function returns an error.
+ *
+ * Returns: The layer's show mask setting.
+ **/
+gboolean
+gimp_layer_get_show_mask (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean show_mask = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-show-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-show-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    show_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return show_mask;
+}
+
+/**
+ * _gimp_layer_get_show_mask: (skip)
+ * @layer_ID: The layer.
+ *
+ * Get the show mask setting of the specified layer.
+ *
+ * This procedure returns the specified layer's show mask setting. This
+ * controls whether the layer or its mask is visible. TRUE indicates
+ * that the mask should be visible. If the layer has no mask, then this
+ * function returns an error.
+ *
+ * Returns: The layer's show mask setting.
+ **/
+gboolean
+_gimp_layer_get_show_mask (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean show_mask = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-show-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-show-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    show_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return show_mask;
+}
+
+/**
+ * gimp_layer_set_show_mask:
+ * @layer: The layer.
+ * @show_mask: The new layer's show mask setting.
+ *
+ * Set the show mask setting of the specified layer.
+ *
+ * This procedure sets the specified layer's show mask setting. This
+ * controls whether the layer or its mask is visible. TRUE indicates
+ * that the mask should be visible. If there is no layer mask, this
+ * function will return an error.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_layer_set_show_mask (GimpLayer *layer,
+                          gboolean   show_mask)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, show_mask,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-show-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-show-mask",
+                                            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_layer_set_show_mask: (skip)
+ * @layer_ID: The layer.
+ * @show_mask: The new layer's show mask setting.
+ *
+ * Set the show mask setting of the specified layer.
+ *
+ * This procedure sets the specified layer's show mask setting. This
+ * controls whether the layer or its mask is visible. TRUE indicates
+ * that the mask should be visible. If there is no layer mask, this
+ * function will return an error.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_layer_set_show_mask (gint32   layer_ID,
+                           gboolean show_mask)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, show_mask,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-set-show-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-show-mask",
+                                            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_layer_get_edit_mask:
+ * @layer: The layer.
+ *
+ * Get the edit mask setting of the specified layer.
+ *
+ * This procedure returns the specified layer's edit mask setting. If
+ * the value is TRUE, then the layer mask for this layer is currently
+ * active, and not the layer.
+ *
+ * Returns: The layer's edit mask setting.
+ **/
+gboolean
+gimp_layer_get_edit_mask (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean edit_mask = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-layer-get-edit-mask",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-edit-mask",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    edit_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return edit_mask;
+}
+
+/**
+ * _gimp_layer_get_edit_mask: (skip)
+ * @layer_ID: The layer.
  *
- * This procedure returns the specified layer's mask, or -1 if none
- * exists.
+ * Get the edit mask setting of the specified layer.
  *
- * Returns: The layer mask.
+ * This procedure returns the specified layer's edit mask setting. If
+ * the value is TRUE, then the layer mask for this layer is currently
+ * active, and not the layer.
+ *
+ * Returns: The layer's edit mask setting.
  **/
-gint32
-gimp_layer_get_mask (gint32 layer_ID)
+gboolean
+_gimp_layer_get_edit_mask (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 mask_ID = -1;
+  gboolean edit_mask = FALSE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -854,83 +2209,82 @@ gimp_layer_get_mask (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-mask",
+                                                "gimp-layer-get-edit-mask",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-edit-mask",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+    edit_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return mask_ID;
+  return edit_mask;
 }
 
 /**
- * gimp_layer_from_mask:
- * @mask_ID: Mask for which to return the layer.
- *
- * Get the specified mask's layer.
+ * gimp_layer_set_edit_mask:
+ * @layer: The layer.
+ * @edit_mask: The new layer's edit mask setting.
  *
- * This procedure returns the specified mask's layer , or -1 if none
- * exists.
+ * Set the edit mask setting of the specified layer.
  *
- * Returns: The mask's layer.
+ * This procedure sets the specified layer's edit mask setting. This
+ * controls whether the layer or it's mask is currently active for
+ * editing. If the specified layer has no layer mask, then this
+ * procedure will return an error.
  *
- * Since: 2.2
+ * Returns: TRUE on success.
  **/
-gint32
-gimp_layer_from_mask (gint32 mask_ID)
+gboolean
+gimp_layer_set_edit_mask (GimpLayer *layer,
+                          gboolean   edit_mask)
 {
   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_LAYER_MASK_ID, mask_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, edit_mask,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-from-mask",
+                                                "gimp-layer-set-edit-mask",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-from-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-edit-mask",
                                             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_layer_add_mask:
- * @layer_ID: The layer to receive the mask.
- * @mask_ID: The mask to add to the layer.
+ * _gimp_layer_set_edit_mask: (skip)
+ * @layer_ID: The layer.
+ * @edit_mask: The new layer's edit mask setting.
  *
- * Add a layer mask to the specified layer.
+ * Set the edit mask setting of the specified layer.
  *
- * This procedure adds a layer mask to the specified layer. Layer masks
- * serve as an additional alpha channel for a layer. This procedure
- * will fail if a number of prerequisites aren't met. The layer cannot
- * already have a layer mask. The specified mask must exist and have
- * the same dimensions as the layer. The layer must have been created
- * for use with the specified image and the mask must have been created
- * with the procedure 'gimp-layer-create-mask'.
+ * This procedure sets the specified layer's edit mask setting. This
+ * controls whether the layer or it's mask is currently active for
+ * editing. If the specified layer has no layer mask, then this
+ * procedure will return an error.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_add_mask (gint32 layer_ID,
-                     gint32 mask_ID)
+_gimp_layer_set_edit_mask (gint32   layer_ID,
+                           gboolean edit_mask)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -939,15 +2293,15 @@ gimp_layer_add_mask (gint32 layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
+                                          G_TYPE_BOOLEAN, edit_mask,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-add-mask",
+                                                "gimp-layer-set-edit-mask",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-add-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-edit-mask",
                                             args);
   gimp_value_array_unref (args);
 
@@ -959,66 +2313,61 @@ gimp_layer_add_mask (gint32 layer_ID,
 }
 
 /**
- * gimp_layer_remove_mask:
- * @layer_ID: The layer from which to remove mask.
- * @mode: Removal mode.
+ * gimp_layer_get_opacity:
+ * @layer: The layer.
  *
- * Remove the specified layer mask from the layer.
+ * Get the opacity of the specified layer.
  *
- * This procedure removes the specified layer mask from the layer. If
- * the mask doesn't exist, an error is returned.
+ * This procedure returns the specified layer's opacity.
  *
- * Returns: TRUE on success.
+ * Returns: The layer opacity.
  **/
-gboolean
-gimp_layer_remove_mask (gint32            layer_ID,
-                        GimpMaskApplyMode mode)
+gdouble
+gimp_layer_get_opacity (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gdouble opacity = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_MASK_APPLY_MODE, mode,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-remove-mask",
+                                                "gimp-layer-get-opacity",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-remove-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-opacity",
                                             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)
+    opacity = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return opacity;
 }
 
 /**
- * gimp_layer_is_floating_sel:
+ * _gimp_layer_get_opacity: (skip)
  * @layer_ID: The layer.
  *
- * Is the specified layer a floating selection?
+ * Get the opacity of the specified layer.
  *
- * This procedure returns whether the layer is a floating selection.
- * Floating selections are special cases of layers which are attached
- * to a specific drawable.
+ * This procedure returns the specified layer's opacity.
  *
- * Returns: TRUE if the layer is a floating selection.
+ * Returns: The layer opacity.
  **/
-gboolean
-gimp_layer_is_floating_sel (gint32 layer_ID)
+gdouble
+_gimp_layer_get_opacity (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean is_floating_sel = FALSE;
+  gdouble opacity = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -1026,76 +2375,76 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-is-floating-sel",
+                                                "gimp-layer-get-opacity",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-is-floating-sel",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-opacity",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    is_floating_sel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    opacity = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return is_floating_sel;
+  return opacity;
 }
 
 /**
- * gimp_layer_get_lock_alpha:
- * @layer_ID: The layer.
+ * gimp_layer_set_opacity:
+ * @layer: The layer.
+ * @opacity: The new layer opacity.
  *
- * Get the lock alpha channel setting of the specified layer.
+ * Set the opacity of the specified layer.
  *
- * This procedure returns the specified layer's lock alpha channel
- * setting.
+ * This procedure sets the specified layer's opacity.
  *
- * Returns: The layer's lock alpha channel setting.
+ * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_get_lock_alpha (gint32 layer_ID)
+gimp_layer_set_opacity (GimpLayer *layer,
+                        gdouble    opacity)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean lock_alpha = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-lock-alpha",
+                                                "gimp-layer-set-opacity",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-lock-alpha",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-opacity",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    lock_alpha = 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 lock_alpha;
+  return success;
 }
 
 /**
- * gimp_layer_set_lock_alpha:
+ * _gimp_layer_set_opacity: (skip)
  * @layer_ID: The layer.
- * @lock_alpha: The new layer's lock alpha channel setting.
+ * @opacity: The new layer opacity.
  *
- * Set the lock alpha channel setting of the specified layer.
+ * Set the opacity of the specified layer.
  *
- * This procedure sets the specified layer's lock alpha channel
- * setting.
+ * This procedure sets the specified layer's opacity.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_set_lock_alpha (gint32   layer_ID,
-                           gboolean lock_alpha)
+_gimp_layer_set_opacity (gint32  layer_ID,
+                         gdouble opacity)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1104,15 +2453,15 @@ gimp_layer_set_lock_alpha (gint32   layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, lock_alpha,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-lock-alpha",
+                                                "gimp-layer-set-opacity",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-lock-alpha",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-opacity",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1124,149 +2473,138 @@ gimp_layer_set_lock_alpha (gint32   layer_ID,
 }
 
 /**
- * gimp_layer_get_apply_mask:
- * @layer_ID: The layer.
+ * gimp_layer_get_mode:
+ * @layer: The layer.
  *
- * Get the apply mask setting of the specified layer.
+ * Get the combination mode of the specified layer.
  *
- * This procedure returns the specified layer's apply mask setting. If
- * the value is TRUE, then the layer mask for this layer is currently
- * being composited with the layer's alpha channel.
+ * This procedure returns the specified layer's combination mode.
  *
- * Returns: The layer's apply mask setting.
+ * Returns: The layer combination mode.
  **/
-gboolean
-gimp_layer_get_apply_mask (gint32 layer_ID)
+GimpLayerMode
+gimp_layer_get_mode (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean apply_mask = FALSE;
+  GimpLayerMode mode = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-apply-mask",
+                                                "gimp-layer-get-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-apply-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-mode",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    apply_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return apply_mask;
+  return mode;
 }
 
 /**
- * gimp_layer_set_apply_mask:
+ * _gimp_layer_get_mode: (skip)
  * @layer_ID: The layer.
- * @apply_mask: The new layer's apply mask setting.
  *
- * Set the apply mask setting of the specified layer.
+ * Get the combination mode of the specified layer.
  *
- * This procedure sets the specified layer's apply mask setting. This
- * controls whether the layer's mask is currently affecting the alpha
- * channel. If there is no layer mask, this function will return an
- * error.
+ * This procedure returns the specified layer's combination mode.
  *
- * Returns: TRUE on success.
+ * Returns: The layer combination mode.
  **/
-gboolean
-gimp_layer_set_apply_mask (gint32   layer_ID,
-                           gboolean apply_mask)
+GimpLayerMode
+_gimp_layer_get_mode (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  GimpLayerMode mode = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, apply_mask,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-apply-mask",
+                                                "gimp-layer-get-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-apply-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-mode",
                                             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)
+    mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return mode;
 }
 
 /**
- * gimp_layer_get_show_mask:
- * @layer_ID: The layer.
+ * gimp_layer_set_mode:
+ * @layer: The layer.
+ * @mode: The new layer combination mode.
  *
- * Get the show mask setting of the specified layer.
+ * Set the combination mode of the specified layer.
  *
- * This procedure returns the specified layer's show mask setting. This
- * controls whether the layer or its mask is visible. TRUE indicates
- * that the mask should be visible. If the layer has no mask, then this
- * function returns an error.
+ * This procedure sets the specified layer's combination mode.
  *
- * Returns: The layer's show mask setting.
+ * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_get_show_mask (gint32 layer_ID)
+gimp_layer_set_mode (GimpLayer     *layer,
+                     GimpLayerMode  mode)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean show_mask = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_MODE, mode,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-show-mask",
+                                                "gimp-layer-set-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-show-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-mode",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    show_mask = 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 show_mask;
+  return success;
 }
 
 /**
- * gimp_layer_set_show_mask:
+ * _gimp_layer_set_mode: (skip)
  * @layer_ID: The layer.
- * @show_mask: The new layer's show mask setting.
+ * @mode: The new layer combination mode.
  *
- * Set the show mask setting of the specified layer.
+ * Set the combination mode of the specified layer.
  *
- * This procedure sets the specified layer's show mask setting. This
- * controls whether the layer or its mask is visible. TRUE indicates
- * that the mask should be visible. If there is no layer mask, this
- * function will return an error.
+ * This procedure sets the specified layer's combination mode.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_layer_set_show_mask (gint32   layer_ID,
-                          gboolean show_mask)
+_gimp_layer_set_mode (gint32        layer_ID,
+                      GimpLayerMode mode)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1275,15 +2613,15 @@ gimp_layer_set_show_mask (gint32   layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, show_mask,
+                                          GIMP_TYPE_LAYER_MODE, mode,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-show-mask",
+                                                "gimp-layer-set-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-show-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-mode",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1295,143 +2633,146 @@ gimp_layer_set_show_mask (gint32   layer_ID,
 }
 
 /**
- * gimp_layer_get_edit_mask:
- * @layer_ID: The layer.
+ * gimp_layer_get_blend_space:
+ * @layer: The layer.
  *
- * Get the edit mask setting of the specified layer.
+ * Get the blend space of the specified layer.
  *
- * This procedure returns the specified layer's edit mask setting. If
- * the value is TRUE, then the layer mask for this layer is currently
- * active, and not the layer.
+ * This procedure returns the specified layer's blend space.
  *
- * Returns: The layer's edit mask setting.
+ * Returns: The layer blend space.
+ *
+ * Since: 2.10
  **/
-gboolean
-gimp_layer_get_edit_mask (gint32 layer_ID)
+GimpLayerColorSpace
+gimp_layer_get_blend_space (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean edit_mask = FALSE;
+  GimpLayerColorSpace blend_space = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-edit-mask",
+                                                "gimp-layer-get-blend-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-edit-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-blend-space",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    edit_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+    blend_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return edit_mask;
+  return blend_space;
 }
 
 /**
- * gimp_layer_set_edit_mask:
+ * _gimp_layer_get_blend_space: (skip)
  * @layer_ID: The layer.
- * @edit_mask: The new layer's edit mask setting.
  *
- * Set the edit mask setting of the specified layer.
+ * Get the blend space of the specified layer.
  *
- * This procedure sets the specified layer's edit mask setting. This
- * controls whether the layer or it's mask is currently active for
- * editing. If the specified layer has no layer mask, then this
- * procedure will return an error.
+ * This procedure returns the specified layer's blend space.
  *
- * Returns: TRUE on success.
+ * Returns: The layer blend space.
+ *
+ * Since: 2.10
  **/
-gboolean
-gimp_layer_set_edit_mask (gint32   layer_ID,
-                          gboolean edit_mask)
+GimpLayerColorSpace
+_gimp_layer_get_blend_space (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  GimpLayerColorSpace blend_space = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, edit_mask,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-edit-mask",
+                                                "gimp-layer-get-blend-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-edit-mask",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-blend-space",
                                             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)
+    blend_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return blend_space;
 }
 
 /**
- * gimp_layer_get_opacity:
- * @layer_ID: The layer.
+ * gimp_layer_set_blend_space:
+ * @layer: The layer.
+ * @blend_space: The new layer blend space.
  *
- * Get the opacity of the specified layer.
+ * Set the blend space of the specified layer.
  *
- * This procedure returns the specified layer's opacity.
+ * This procedure sets the specified layer's blend space.
  *
- * Returns: The layer opacity.
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
  **/
-gdouble
-gimp_layer_get_opacity (gint32 layer_ID)
+gboolean
+gimp_layer_set_blend_space (GimpLayer           *layer,
+                            GimpLayerColorSpace  blend_space)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gdouble opacity = 0.0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, blend_space,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-opacity",
+                                                "gimp-layer-set-blend-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-opacity",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-blend-space",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    opacity = g_value_get_double (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 opacity;
+  return success;
 }
 
 /**
- * gimp_layer_set_opacity:
+ * _gimp_layer_set_blend_space: (skip)
  * @layer_ID: The layer.
- * @opacity: The new layer opacity.
+ * @blend_space: The new layer blend space.
  *
- * Set the opacity of the specified layer.
+ * Set the blend space of the specified layer.
  *
- * This procedure sets the specified layer's opacity.
+ * This procedure sets the specified layer's blend space.
  *
  * Returns: TRUE on success.
+ *
+ * Since: 2.10
  **/
 gboolean
-gimp_layer_set_opacity (gint32  layer_ID,
-                        gdouble opacity)
+_gimp_layer_set_blend_space (gint32              layer_ID,
+                             GimpLayerColorSpace blend_space)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1440,15 +2781,15 @@ gimp_layer_set_opacity (gint32  layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, blend_space,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-opacity",
+                                                "gimp-layer-set-blend-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-opacity",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-blend-space",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1460,142 +2801,146 @@ gimp_layer_set_opacity (gint32  layer_ID,
 }
 
 /**
- * gimp_layer_get_mode:
- * @layer_ID: The layer.
+ * gimp_layer_get_composite_space:
+ * @layer: The layer.
  *
- * Get the combination mode of the specified layer.
+ * Get the composite space of the specified layer.
  *
- * This procedure returns the specified layer's combination mode.
+ * This procedure returns the specified layer's composite space.
  *
- * Returns: The layer combination mode.
+ * Returns: The layer composite space.
+ *
+ * Since: 2.10
  **/
-GimpLayerMode
-gimp_layer_get_mode (gint32 layer_ID)
+GimpLayerColorSpace
+gimp_layer_get_composite_space (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpLayerMode mode = 0;
+  GimpLayerColorSpace composite_space = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-mode",
+                                                "gimp-layer-get-composite-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-mode",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-space",
                                             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));
+    composite_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return mode;
+  return composite_space;
 }
 
 /**
- * gimp_layer_set_mode:
+ * _gimp_layer_get_composite_space: (skip)
  * @layer_ID: The layer.
- * @mode: The new layer combination mode.
  *
- * Set the combination mode of the specified layer.
+ * Get the composite space of the specified layer.
  *
- * This procedure sets the specified layer's combination mode.
+ * This procedure returns the specified layer's composite space.
  *
- * Returns: TRUE on success.
+ * Returns: The layer composite space.
+ *
+ * Since: 2.10
  **/
-gboolean
-gimp_layer_set_mode (gint32        layer_ID,
-                     GimpLayerMode mode)
+GimpLayerColorSpace
+_gimp_layer_get_composite_space (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  GimpLayerColorSpace composite_space = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_LAYER_MODE, mode,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-mode",
+                                                "gimp-layer-get-composite-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-mode",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-space",
                                             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)
+    composite_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return composite_space;
 }
 
 /**
- * gimp_layer_get_blend_space:
- * @layer_ID: The layer.
+ * gimp_layer_set_composite_space:
+ * @layer: The layer.
+ * @composite_space: The new layer composite space.
  *
- * Get the blend space of the specified layer.
+ * Set the composite space of the specified layer.
  *
- * This procedure returns the specified layer's blend space.
+ * This procedure sets the specified layer's composite space.
  *
- * Returns: The layer blend space.
+ * Returns: TRUE on success.
  *
  * Since: 2.10
  **/
-GimpLayerColorSpace
-gimp_layer_get_blend_space (gint32 layer_ID)
+gboolean
+gimp_layer_set_composite_space (GimpLayer           *layer,
+                                GimpLayerColorSpace  composite_space)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpLayerColorSpace blend_space = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, composite_space,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-blend-space",
+                                                "gimp-layer-set-composite-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-blend-space",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-space",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    blend_space = g_value_get_enum (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 blend_space;
+  return success;
 }
 
 /**
- * gimp_layer_set_blend_space:
+ * _gimp_layer_set_composite_space: (skip)
  * @layer_ID: The layer.
- * @blend_space: The new layer blend space.
+ * @composite_space: The new layer composite space.
  *
- * Set the blend space of the specified layer.
+ * Set the composite space of the specified layer.
  *
- * This procedure sets the specified layer's blend space.
+ * This procedure sets the specified layer's composite space.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.10
  **/
 gboolean
-gimp_layer_set_blend_space (gint32              layer_ID,
-                            GimpLayerColorSpace blend_space)
+_gimp_layer_set_composite_space (gint32              layer_ID,
+                                 GimpLayerColorSpace composite_space)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1604,15 +2949,15 @@ gimp_layer_set_blend_space (gint32              layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_LAYER_COLOR_SPACE, blend_space,
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, composite_space,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-blend-space",
+                                                "gimp-layer-set-composite-space",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-blend-space",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-space",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1624,132 +2969,132 @@ gimp_layer_set_blend_space (gint32              layer_ID,
 }
 
 /**
- * gimp_layer_get_composite_space:
- * @layer_ID: The layer.
+ * gimp_layer_get_composite_mode:
+ * @layer: The layer.
  *
- * Get the composite space of the specified layer.
+ * Get the composite mode of the specified layer.
  *
- * This procedure returns the specified layer's composite space.
+ * This procedure returns the specified layer's composite mode.
  *
- * Returns: The layer composite space.
+ * Returns: The layer composite mode.
  *
  * Since: 2.10
  **/
-GimpLayerColorSpace
-gimp_layer_get_composite_space (gint32 layer_ID)
+GimpLayerCompositeMode
+gimp_layer_get_composite_mode (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpLayerColorSpace composite_space = 0;
+  GimpLayerCompositeMode composite_mode = 0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-composite-space",
+                                                "gimp-layer-get-composite-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-space",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-mode",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    composite_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+    composite_mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return composite_space;
+  return composite_mode;
 }
 
 /**
- * gimp_layer_set_composite_space:
+ * _gimp_layer_get_composite_mode: (skip)
  * @layer_ID: The layer.
- * @composite_space: The new layer composite space.
  *
- * Set the composite space of the specified layer.
+ * Get the composite mode of the specified layer.
  *
- * This procedure sets the specified layer's composite space.
+ * This procedure returns the specified layer's composite mode.
  *
- * Returns: TRUE on success.
+ * Returns: The layer composite mode.
  *
  * Since: 2.10
  **/
-gboolean
-gimp_layer_set_composite_space (gint32              layer_ID,
-                                GimpLayerColorSpace composite_space)
+GimpLayerCompositeMode
+_gimp_layer_get_composite_mode (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  GimpLayerCompositeMode composite_mode = 0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_LAYER_COLOR_SPACE, composite_space,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-set-composite-space",
+                                                "gimp-layer-get-composite-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-space",
+    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-mode",
                                             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)
+    composite_mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return composite_mode;
 }
 
 /**
- * gimp_layer_get_composite_mode:
- * @layer_ID: The layer.
+ * gimp_layer_set_composite_mode:
+ * @layer: The layer.
+ * @composite_mode: The new layer composite mode.
  *
- * Get the composite mode of the specified layer.
+ * Set the composite mode of the specified layer.
  *
- * This procedure returns the specified layer's composite mode.
+ * This procedure sets the specified layer's composite mode.
  *
- * Returns: The layer composite mode.
+ * Returns: TRUE on success.
  *
  * Since: 2.10
  **/
-GimpLayerCompositeMode
-gimp_layer_get_composite_mode (gint32 layer_ID)
+gboolean
+gimp_layer_set_composite_mode (GimpLayer              *layer,
+                               GimpLayerCompositeMode  composite_mode)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpLayerCompositeMode composite_mode = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_LAYER_COMPOSITE_MODE, composite_mode,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-get-composite-mode",
+                                                "gimp-layer-set-composite-mode",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-mode",
+    return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-mode",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    composite_mode = g_value_get_enum (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 composite_mode;
+  return success;
 }
 
 /**
- * gimp_layer_set_composite_mode:
+ * _gimp_layer_set_composite_mode: (skip)
  * @layer_ID: The layer.
  * @composite_mode: The new layer composite mode.
  *
@@ -1762,8 +3107,8 @@ gimp_layer_get_composite_mode (gint32 layer_ID)
  * Since: 2.10
  **/
 gboolean
-gimp_layer_set_composite_mode (gint32                 layer_ID,
-                               GimpLayerCompositeMode composite_mode)
+_gimp_layer_set_composite_mode (gint32                 layer_ID,
+                                GimpLayerCompositeMode composite_mode)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h
index 453b6f177f..3070256ff9 100644
--- a/libgimp/gimplayer_pdb.h
+++ b/libgimp/gimplayer_pdb.h
@@ -32,75 +32,76 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-G_GNUC_INTERNAL gint32 _gimp_layer_copy                (gint32                 layer_ID,
-                                                        gboolean               add_alpha);
-gboolean               gimp_layer_add_alpha            (gint32                 layer_ID);
-gboolean               gimp_layer_flatten              (gint32                 layer_ID);
-gboolean               gimp_layer_scale                (gint32                 layer_ID,
-                                                        gint                   new_width,
-                                                        gint                   new_height,
-                                                        gboolean               local_origin);
-gboolean               gimp_layer_resize               (gint32                 layer_ID,
-                                                        gint                   new_width,
-                                                        gint                   new_height,
-                                                        gint                   offx,
-                                                        gint                   offy);
-gboolean               gimp_layer_resize_to_image_size (gint32                 layer_ID);
-gboolean               gimp_layer_set_offsets          (gint32                 layer_ID,
-                                                        gint                   offx,
-                                                        gint                   offy);
-gint32                 gimp_layer_create_mask          (gint32                 layer_ID,
-                                                        GimpAddMaskType        mask_type);
-gint32                 gimp_layer_get_mask             (gint32                 layer_ID);
-gint32                 gimp_layer_from_mask            (gint32                 mask_ID);
-gboolean               gimp_layer_add_mask             (gint32                 layer_ID,
-                                                        gint32                 mask_ID);
-gboolean               gimp_layer_remove_mask          (gint32                 layer_ID,
-                                                        GimpMaskApplyMode      mode);
-gboolean               gimp_layer_is_floating_sel      (gint32                 layer_ID);
-gboolean               gimp_layer_get_lock_alpha       (gint32                 layer_ID);
-gboolean               gimp_layer_set_lock_alpha       (gint32                 layer_ID,
-                                                        gboolean               lock_alpha);
-gboolean               gimp_layer_get_apply_mask       (gint32                 layer_ID);
-gboolean               gimp_layer_set_apply_mask       (gint32                 layer_ID,
-                                                        gboolean               apply_mask);
-gboolean               gimp_layer_get_show_mask        (gint32                 layer_ID);
-gboolean               gimp_layer_set_show_mask        (gint32                 layer_ID,
-                                                        gboolean               show_mask);
-gboolean               gimp_layer_get_edit_mask        (gint32                 layer_ID);
-gboolean               gimp_layer_set_edit_mask        (gint32                 layer_ID,
-                                                        gboolean               edit_mask);
-gdouble                gimp_layer_get_opacity          (gint32                 layer_ID);
-gboolean               gimp_layer_set_opacity          (gint32                 layer_ID,
-                                                        gdouble                opacity);
-GimpLayerMode          gimp_layer_get_mode             (gint32                 layer_ID);
-gboolean               gimp_layer_set_mode             (gint32                 layer_ID,
-                                                        GimpLayerMode          mode);
-GimpLayerColorSpace    gimp_layer_get_blend_space      (gint32                 layer_ID);
-gboolean               gimp_layer_set_blend_space      (gint32                 layer_ID,
-                                                        GimpLayerColorSpace    blend_space);
-GimpLayerColorSpace    gimp_layer_get_composite_space  (gint32                 layer_ID);
-gboolean               gimp_layer_set_composite_space  (gint32                 layer_ID,
-                                                        GimpLayerColorSpace    composite_space);
-GimpLayerCompositeMode gimp_layer_get_composite_mode   (gint32                 layer_ID);
-gboolean               gimp_layer_set_composite_mode   (gint32                 layer_ID,
-                                                        GimpLayerCompositeMode composite_mode);
+
 
 #ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
-G_GNUC_INTERNAL gint32 _gimp_layer_new              (GimpImage     *image,
-                                                     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);
-gint32                 gimp_layer_new_from_drawable (gint32         drawable_ID,
-                                                     GimpImage     *dest_image);
-gint32                 gimp_layer_group_new         (GimpImage     *image);
+G_GNUC_INTERNAL GimpLayer* _gimp_layer_new                 (GimpImage              *image,
+                                                            gint                    width,
+                                                            gint                    height,
+                                                            GimpImageType           type,
+                                                            const gchar            *name,
+                                                            gdouble                 opacity,
+                                                            GimpLayerMode           mode);
+GimpLayer*                 gimp_layer_new_from_visible     (GimpImage              *image,
+                                                            GimpImage              *dest_image,
+                                                            const gchar            *name);
+GimpLayer*                 gimp_layer_new_from_drawable    (GimpDrawable           *drawable,
+                                                            GimpImage              *dest_image);
+GimpLayer*                 gimp_layer_group_new            (GimpImage              *image);
+G_GNUC_INTERNAL GimpLayer* _gimp_layer_copy                (GimpLayer              *layer,
+                                                            gboolean                add_alpha);
+gboolean                   gimp_layer_add_alpha            (GimpLayer              *layer);
+gboolean                   gimp_layer_flatten              (GimpLayer              *layer);
+gboolean                   gimp_layer_scale                (GimpLayer              *layer,
+                                                            gint                    new_width,
+                                                            gint                    new_height,
+                                                            gboolean                local_origin);
+gboolean                   gimp_layer_resize               (GimpLayer              *layer,
+                                                            gint                    new_width,
+                                                            gint                    new_height,
+                                                            gint                    offx,
+                                                            gint                    offy);
+gboolean                   gimp_layer_resize_to_image_size (GimpLayer              *layer);
+gboolean                   gimp_layer_set_offsets          (GimpLayer              *layer,
+                                                            gint                    offx,
+                                                            gint                    offy);
+gint32                     gimp_layer_create_mask          (GimpLayer              *layer,
+                                                            GimpAddMaskType         mask_type);
+gint32                     gimp_layer_get_mask             (GimpLayer              *layer);
+GimpLayer*                 gimp_layer_from_mask            (gint32                  mask_ID);
+gboolean                   gimp_layer_add_mask             (GimpLayer              *layer,
+                                                            gint32                  mask_ID);
+gboolean                   gimp_layer_remove_mask          (GimpLayer              *layer,
+                                                            GimpMaskApplyMode       mode);
+gboolean                   gimp_layer_is_floating_sel      (GimpLayer              *layer);
+gboolean                   gimp_layer_get_lock_alpha       (GimpLayer              *layer);
+gboolean                   gimp_layer_set_lock_alpha       (GimpLayer              *layer,
+                                                            gboolean                lock_alpha);
+gboolean                   gimp_layer_get_apply_mask       (GimpLayer              *layer);
+gboolean                   gimp_layer_set_apply_mask       (GimpLayer              *layer,
+                                                            gboolean                apply_mask);
+gboolean                   gimp_layer_get_show_mask        (GimpLayer              *layer);
+gboolean                   gimp_layer_set_show_mask        (GimpLayer              *layer,
+                                                            gboolean                show_mask);
+gboolean                   gimp_layer_get_edit_mask        (GimpLayer              *layer);
+gboolean                   gimp_layer_set_edit_mask        (GimpLayer              *layer,
+                                                            gboolean                edit_mask);
+gdouble                    gimp_layer_get_opacity          (GimpLayer              *layer);
+gboolean                   gimp_layer_set_opacity          (GimpLayer              *layer,
+                                                            gdouble                 opacity);
+GimpLayerMode              gimp_layer_get_mode             (GimpLayer              *layer);
+gboolean                   gimp_layer_set_mode             (GimpLayer              *layer,
+                                                            GimpLayerMode           mode);
+GimpLayerColorSpace        gimp_layer_get_blend_space      (GimpLayer              *layer);
+gboolean                   gimp_layer_set_blend_space      (GimpLayer              *layer,
+                                                            GimpLayerColorSpace     blend_space);
+GimpLayerColorSpace        gimp_layer_get_composite_space  (GimpLayer              *layer);
+gboolean                   gimp_layer_set_composite_space  (GimpLayer              *layer,
+                                                            GimpLayerColorSpace     composite_space);
+GimpLayerCompositeMode     gimp_layer_get_composite_mode   (GimpLayer              *layer);
+gboolean                   gimp_layer_set_composite_mode   (GimpLayer              *layer,
+                                                            GimpLayerCompositeMode  composite_mode);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
@@ -108,6 +109,37 @@ gint32                 gimp_layer_group_new         (GimpImage     *image);
 #define gimp_layer_new_from_visible _gimp_layer_new_from_visible
 #define gimp_layer_new_from_drawable _gimp_layer_new_from_drawable
 #define gimp_layer_group_new _gimp_layer_group_new
+#define _gimp_layer_copy __gimp_layer_copy
+#define gimp_layer_add_alpha _gimp_layer_add_alpha
+#define gimp_layer_flatten _gimp_layer_flatten
+#define gimp_layer_scale _gimp_layer_scale
+#define gimp_layer_resize _gimp_layer_resize
+#define gimp_layer_resize_to_image_size _gimp_layer_resize_to_image_size
+#define gimp_layer_set_offsets _gimp_layer_set_offsets
+#define gimp_layer_create_mask _gimp_layer_create_mask
+#define gimp_layer_get_mask _gimp_layer_get_mask
+#define gimp_layer_from_mask _gimp_layer_from_mask
+#define gimp_layer_add_mask _gimp_layer_add_mask
+#define gimp_layer_remove_mask _gimp_layer_remove_mask
+#define gimp_layer_is_floating_sel _gimp_layer_is_floating_sel
+#define gimp_layer_get_lock_alpha _gimp_layer_get_lock_alpha
+#define gimp_layer_set_lock_alpha _gimp_layer_set_lock_alpha
+#define gimp_layer_get_apply_mask _gimp_layer_get_apply_mask
+#define gimp_layer_set_apply_mask _gimp_layer_set_apply_mask
+#define gimp_layer_get_show_mask _gimp_layer_get_show_mask
+#define gimp_layer_set_show_mask _gimp_layer_set_show_mask
+#define gimp_layer_get_edit_mask _gimp_layer_get_edit_mask
+#define gimp_layer_set_edit_mask _gimp_layer_set_edit_mask
+#define gimp_layer_get_opacity _gimp_layer_get_opacity
+#define gimp_layer_set_opacity _gimp_layer_set_opacity
+#define gimp_layer_get_mode _gimp_layer_get_mode
+#define gimp_layer_set_mode _gimp_layer_set_mode
+#define gimp_layer_get_blend_space _gimp_layer_get_blend_space
+#define gimp_layer_set_blend_space _gimp_layer_set_blend_space
+#define gimp_layer_get_composite_space _gimp_layer_get_composite_space
+#define gimp_layer_set_composite_space _gimp_layer_set_composite_space
+#define gimp_layer_get_composite_mode _gimp_layer_get_composite_mode
+#define gimp_layer_set_composite_mode _gimp_layer_set_composite_mode
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -116,19 +148,72 @@ gint32                 gimp_layer_group_new         (GimpImage     *image);
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-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  (gint32         image_ID,
-                                      gint32         dest_image_ID,
-                                      const gchar   *name);
-gint32 _gimp_layer_new_from_drawable (gint32         drawable_ID,
-                                      gint32         dest_image_ID);
-gint32 _gimp_layer_group_new         (gint32         image_ID);
+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     (gint32                  image_ID,
+                                                         gint32                  dest_image_ID,
+                                                         const gchar            *name);
+gint32                 _gimp_layer_new_from_drawable    (gint32                  drawable_ID,
+                                                         gint32                  dest_image_ID);
+gint32                 _gimp_layer_group_new            (gint32                  image_ID);
+gint32                 __gimp_layer_copy                (gint32                  layer_ID,
+                                                         gboolean                add_alpha);
+gboolean               _gimp_layer_add_alpha            (gint32                  layer_ID);
+gboolean               _gimp_layer_flatten              (gint32                  layer_ID);
+gboolean               _gimp_layer_scale                (gint32                  layer_ID,
+                                                         gint                    new_width,
+                                                         gint                    new_height,
+                                                         gboolean                local_origin);
+gboolean               _gimp_layer_resize               (gint32                  layer_ID,
+                                                         gint                    new_width,
+                                                         gint                    new_height,
+                                                         gint                    offx,
+                                                         gint                    offy);
+gboolean               _gimp_layer_resize_to_image_size (gint32                  layer_ID);
+gboolean               _gimp_layer_set_offsets          (gint32                  layer_ID,
+                                                         gint                    offx,
+                                                         gint                    offy);
+gint32                 _gimp_layer_create_mask          (gint32                  layer_ID,
+                                                         GimpAddMaskType         mask_type);
+gint32                 _gimp_layer_get_mask             (gint32                  layer_ID);
+gint32                 _gimp_layer_from_mask            (gint32                  mask_ID);
+gboolean               _gimp_layer_add_mask             (gint32                  layer_ID,
+                                                         gint32                  mask_ID);
+gboolean               _gimp_layer_remove_mask          (gint32                  layer_ID,
+                                                         GimpMaskApplyMode       mode);
+gboolean               _gimp_layer_is_floating_sel      (gint32                  layer_ID);
+gboolean               _gimp_layer_get_lock_alpha       (gint32                  layer_ID);
+gboolean               _gimp_layer_set_lock_alpha       (gint32                  layer_ID,
+                                                         gboolean                lock_alpha);
+gboolean               _gimp_layer_get_apply_mask       (gint32                  layer_ID);
+gboolean               _gimp_layer_set_apply_mask       (gint32                  layer_ID,
+                                                         gboolean                apply_mask);
+gboolean               _gimp_layer_get_show_mask        (gint32                  layer_ID);
+gboolean               _gimp_layer_set_show_mask        (gint32                  layer_ID,
+                                                         gboolean                show_mask);
+gboolean               _gimp_layer_get_edit_mask        (gint32                  layer_ID);
+gboolean               _gimp_layer_set_edit_mask        (gint32                  layer_ID,
+                                                         gboolean                edit_mask);
+gdouble                _gimp_layer_get_opacity          (gint32                  layer_ID);
+gboolean               _gimp_layer_set_opacity          (gint32                  layer_ID,
+                                                         gdouble                 opacity);
+GimpLayerMode          _gimp_layer_get_mode             (gint32                  layer_ID);
+gboolean               _gimp_layer_set_mode             (gint32                  layer_ID,
+                                                         GimpLayerMode           mode);
+GimpLayerColorSpace    _gimp_layer_get_blend_space      (gint32                  layer_ID);
+gboolean               _gimp_layer_set_blend_space      (gint32                  layer_ID,
+                                                         GimpLayerColorSpace     blend_space);
+GimpLayerColorSpace    _gimp_layer_get_composite_space  (gint32                  layer_ID);
+gboolean               _gimp_layer_set_composite_space  (gint32                  layer_ID,
+                                                         GimpLayerColorSpace     composite_space);
+GimpLayerCompositeMode _gimp_layer_get_composite_mode   (gint32                  layer_ID);
+gboolean               _gimp_layer_set_composite_mode   (gint32                  layer_ID,
+                                                         GimpLayerCompositeMode  composite_mode);
 
 
 G_END_DECLS
diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c
index 6f782f4e6e..4563025c57 100644
--- a/libgimp/gimppainttools_pdb.c
+++ b/libgimp/gimppainttools_pdb.c
@@ -36,7 +36,7 @@
 
 /**
  * gimp_airbrush:
- * @drawable_ID: The affected drawable.
+ * @drawable: The affected drawable.
  * @pressure: The pressure of the airbrush strokes.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
@@ -52,7 +52,7 @@
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_airbrush (gint32         drawable_ID,
+gimp_airbrush (GimpDrawable  *drawable,
                gdouble        pressure,
                gint           num_strokes,
                const gdouble *strokes)
@@ -62,6 +62,58 @@ gimp_airbrush (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, pressure,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-airbrush",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-airbrush",
+                                            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_airbrush: (skip)
+ * @drawable_ID: The affected drawable.
+ * @pressure: The pressure of the airbrush strokes.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Paint in the current brush with varying pressure. Paint application
+ * is time-dependent.
+ *
+ * This tool simulates the use of an airbrush. Paint pressure
+ * represents the relative intensity of the paint application. High
+ * pressure results in a thicker layer of paint while low pressure
+ * results in a thinner layer.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_airbrush (gint32         drawable_ID,
+                gdouble        pressure,
+                gint           num_strokes,
+                const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_DOUBLE, pressure,
@@ -88,7 +140,7 @@ gimp_airbrush (gint32         drawable_ID,
 
 /**
  * gimp_airbrush_default:
- * @drawable_ID: The affected drawable.
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
@@ -103,7 +155,7 @@ gimp_airbrush (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_airbrush_default (gint32         drawable_ID,
+gimp_airbrush_default (GimpDrawable  *drawable,
                        gint           num_strokes,
                        const gdouble *strokes)
 {
@@ -112,6 +164,55 @@ gimp_airbrush_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-airbrush-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-airbrush-default",
+                                            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_airbrush_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Paint in the current brush with varying pressure. Paint application
+ * is time-dependent.
+ *
+ * This tool simulates the use of an airbrush. It is similar to
+ * gimp_airbrush() except that the pressure is derived from the
+ * airbrush tools options box. It the option has not been set the
+ * default for the option will be used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_airbrush_default (gint32         drawable_ID,
+                        gint           num_strokes,
+                        const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_INT, num_strokes,
@@ -137,8 +238,8 @@ gimp_airbrush_default (gint32         drawable_ID,
 
 /**
  * gimp_clone:
- * @drawable_ID: The affected drawable.
- * @src_drawable_ID: The source drawable.
+ * @drawable: The affected drawable.
+ * @src_drawable: The source drawable.
  * @clone_type: The type of clone.
  * @src_x: The x coordinate in the source image.
  * @src_y: The y coordinate in the source image.
@@ -163,8 +264,8 @@ gimp_airbrush_default (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_clone (gint32         drawable_ID,
-            gint32         src_drawable_ID,
+gimp_clone (GimpDrawable  *drawable,
+            GimpDrawable  *src_drawable,
             GimpCloneType  clone_type,
             gdouble        src_x,
             gdouble        src_y,
@@ -177,8 +278,8 @@ gimp_clone (gint32         drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (src_drawable)),
                                           GIMP_TYPE_CLONE_TYPE, clone_type,
                                           G_TYPE_DOUBLE, src_x,
                                           G_TYPE_DOUBLE, src_y,
@@ -204,26 +305,40 @@ gimp_clone (gint32         drawable_ID,
 }
 
 /**
- * gimp_clone_default:
+ * _gimp_clone: (skip)
  * @drawable_ID: The affected drawable.
+ * @src_drawable_ID: The source drawable.
+ * @clone_type: The type of clone.
+ * @src_x: The x coordinate in the source image.
+ * @src_y: The y coordinate in the source image.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
  * Clone from the source to the dest drawable using the current brush
  *
  * This tool clones (copies) from the source drawable starting at the
- * specified source coordinates to the dest drawable. This function
- * performs exactly the same as the gimp_clone() function except that
- * the tools arguments are obtained from the clones option dialog. It
- * this dialog has not been activated then the dialogs default values
- * will be used.
+ * specified source coordinates to the dest drawable. If the
+ * \"clone_type\" argument is set to PATTERN-CLONE, then the current
+ * pattern is used as the source and the \"src_drawable\" argument is
+ * ignored. Pattern cloning assumes a tileable pattern and mods the sum
+ * of the src coordinates and subsequent stroke offsets with the width
+ * and height of the pattern. For image cloning, if the sum of the src
+ * coordinates and subsequent stroke offsets exceeds the extents of the
+ * src drawable, then no paint is transferred. The clone tool is
+ * capable of transforming between any image types including
+ * RGB-&gt;Indexed--although converting from any type to indexed is
+ * significantly slower.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_clone_default (gint32         drawable_ID,
-                    gint           num_strokes,
-                    const gdouble *strokes)
+_gimp_clone (gint32         drawable_ID,
+             gint32         src_drawable_ID,
+             GimpCloneType  clone_type,
+             gdouble        src_x,
+             gdouble        src_y,
+             gint           num_strokes,
+             const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -232,17 +347,21 @@ gimp_clone_default (gint32         drawable_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
+                                          GIMP_TYPE_CLONE_TYPE, clone_type,
+                                          G_TYPE_DOUBLE, src_x,
+                                          G_TYPE_DOUBLE, src_y,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 6), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-clone-default",
+                                                "gimp-clone",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-clone-default",
+    return_vals = gimp_run_procedure_array ("gimp-clone",
                                             args);
   gimp_value_array_unref (args);
 
@@ -254,28 +373,26 @@ gimp_clone_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_convolve:
- * @drawable_ID: The affected drawable.
- * @pressure: The pressure.
- * @convolve_type: Convolve type.
+ * gimp_clone_default:
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Convolve (Blur, Sharpen) using the current brush.
+ * Clone from the source to the dest drawable using the current brush
  *
- * This tool convolves the specified drawable with either a sharpening
- * or blurring kernel. The pressure parameter controls the magnitude of
- * the operation. Like the paintbrush, this tool linearly interpolates
- * between the specified stroke coordinates.
+ * This tool clones (copies) from the source drawable starting at the
+ * specified source coordinates to the dest drawable. This function
+ * performs exactly the same as the gimp_clone() function except that
+ * the tools arguments are obtained from the clones option dialog. It
+ * this dialog has not been activated then the dialogs default values
+ * will be used.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_convolve (gint32            drawable_ID,
-               gdouble           pressure,
-               GimpConvolveType  convolve_type,
-               gint              num_strokes,
-               const gdouble    *strokes)
+gimp_clone_default (GimpDrawable  *drawable,
+                    gint           num_strokes,
+                    const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -283,20 +400,18 @@ gimp_convolve (gint32            drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_DOUBLE, pressure,
-                                          GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-convolve",
+                                                "gimp-clone-default",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-convolve",
+    return_vals = gimp_run_procedure_array ("gimp-clone-default",
                                             args);
   gimp_value_array_unref (args);
 
@@ -308,25 +423,26 @@ gimp_convolve (gint32            drawable_ID,
 }
 
 /**
- * gimp_convolve_default:
+ * _gimp_clone_default: (skip)
  * @drawable_ID: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Convolve (Blur, Sharpen) using the current brush.
+ * Clone from the source to the dest drawable using the current brush
  *
- * This tool convolves the specified drawable with either a sharpening
- * or blurring kernel. This function performs exactly the same as the
- * gimp_convolve() function except that the tools arguments are
- * obtained from the convolve option dialog. It this dialog has not
- * been activated then the dialogs default values will be used.
+ * This tool clones (copies) from the source drawable starting at the
+ * specified source coordinates to the dest drawable. This function
+ * performs exactly the same as the gimp_clone() function except that
+ * the tools arguments are obtained from the clones option dialog. It
+ * this dialog has not been activated then the dialogs default values
+ * will be used.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_convolve_default (gint32         drawable_ID,
-                       gint           num_strokes,
-                       const gdouble *strokes)
+_gimp_clone_default (gint32         drawable_ID,
+                     gint           num_strokes,
+                     const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -342,10 +458,10 @@ gimp_convolve_default (gint32         drawable_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-convolve-default",
+                                                "gimp-clone-default",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-convolve-default",
+    return_vals = gimp_run_procedure_array ("gimp-clone-default",
                                             args);
   gimp_value_array_unref (args);
 
@@ -357,27 +473,28 @@ gimp_convolve_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_dodgeburn:
- * @drawable_ID: The affected drawable.
- * @exposure: The exposure of the strokes.
- * @dodgeburn_type: The type either dodge or burn.
- * @dodgeburn_mode: The mode.
+ * gimp_convolve:
+ * @drawable: The affected drawable.
+ * @pressure: The pressure.
+ * @convolve_type: Convolve type.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Dodgeburn image with varying exposure.
+ * Convolve (Blur, Sharpen) using the current brush.
  *
- * Dodgeburn. More details here later.
+ * This tool convolves the specified drawable with either a sharpening
+ * or blurring kernel. The pressure parameter controls the magnitude of
+ * the operation. Like the paintbrush, this tool linearly interpolates
+ * between the specified stroke coordinates.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_dodgeburn (gint32             drawable_ID,
-                gdouble            exposure,
-                GimpDodgeBurnType  dodgeburn_type,
-                GimpTransferMode   dodgeburn_mode,
-                gint               num_strokes,
-                const gdouble     *strokes)
+gimp_convolve (GimpDrawable     *drawable,
+               gdouble           pressure,
+               GimpConvolveType  convolve_type,
+               gint              num_strokes,
+               const gdouble    *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -385,21 +502,20 @@ gimp_dodgeburn (gint32             drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_DOUBLE, exposure,
-                                          GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
-                                          GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, pressure,
+                                          GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-dodgeburn",
+                                                "gimp-convolve",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-dodgeburn",
+    return_vals = gimp_run_procedure_array ("gimp-convolve",
                                             args);
   gimp_value_array_unref (args);
 
@@ -411,24 +527,28 @@ gimp_dodgeburn (gint32             drawable_ID,
 }
 
 /**
- * gimp_dodgeburn_default:
+ * _gimp_convolve: (skip)
  * @drawable_ID: The affected drawable.
+ * @pressure: The pressure.
+ * @convolve_type: Convolve type.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Dodgeburn image with varying exposure. This is the same as the
- * gimp_dodgeburn() function except that the exposure, type and mode
- * are taken from the tools option dialog. If the dialog has not been
- * activated then the defaults as used by the dialog will be used.
+ * Convolve (Blur, Sharpen) using the current brush.
  *
- * Dodgeburn. More details here later.
+ * This tool convolves the specified drawable with either a sharpening
+ * or blurring kernel. The pressure parameter controls the magnitude of
+ * the operation. Like the paintbrush, this tool linearly interpolates
+ * between the specified stroke coordinates.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_dodgeburn_default (gint32         drawable_ID,
-                        gint           num_strokes,
-                        const gdouble *strokes)
+_gimp_convolve (gint32            drawable_ID,
+                gdouble           pressure,
+                GimpConvolveType  convolve_type,
+                gint              num_strokes,
+                const gdouble    *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -437,17 +557,19 @@ gimp_dodgeburn_default (gint32         drawable_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, pressure,
+                                          GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-dodgeburn-default",
+                                                "gimp-convolve",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-dodgeburn-default",
+    return_vals = gimp_run_procedure_array ("gimp-convolve",
                                             args);
   gimp_value_array_unref (args);
 
@@ -459,17 +581,374 @@ gimp_dodgeburn_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_eraser:
- * @drawable_ID: The affected drawable.
+ * gimp_convolve_default:
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
- * @hardness: How to apply the brush.
- * @method: The paint method to use.
  *
- * Erase using the current brush.
+ * Convolve (Blur, Sharpen) using the current brush.
  *
- * This tool erases using the current brush mask. If the specified
- * drawable contains an alpha channel, then the erased pixels will
+ * This tool convolves the specified drawable with either a sharpening
+ * or blurring kernel. This function performs exactly the same as the
+ * gimp_convolve() function except that the tools arguments are
+ * obtained from the convolve option dialog. It this dialog has not
+ * been activated then the dialogs default values will be used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_convolve_default (GimpDrawable  *drawable,
+                       gint           num_strokes,
+                       const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-convolve-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-convolve-default",
+                                            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_convolve_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Convolve (Blur, Sharpen) using the current brush.
+ *
+ * This tool convolves the specified drawable with either a sharpening
+ * or blurring kernel. This function performs exactly the same as the
+ * gimp_convolve() function except that the tools arguments are
+ * obtained from the convolve option dialog. It this dialog has not
+ * been activated then the dialogs default values will be used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_convolve_default (gint32         drawable_ID,
+                        gint           num_strokes,
+                        const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-convolve-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-convolve-default",
+                                            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_dodgeburn:
+ * @drawable: The affected drawable.
+ * @exposure: The exposure of the strokes.
+ * @dodgeburn_type: The type either dodge or burn.
+ * @dodgeburn_mode: The mode.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Dodgeburn image with varying exposure.
+ *
+ * Dodgeburn. More details here later.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_dodgeburn (GimpDrawable      *drawable,
+                gdouble            exposure,
+                GimpDodgeBurnType  dodgeburn_type,
+                GimpTransferMode   dodgeburn_mode,
+                gint               num_strokes,
+                const gdouble     *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, exposure,
+                                          GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
+                                          GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-dodgeburn",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-dodgeburn",
+                                            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_dodgeburn: (skip)
+ * @drawable_ID: The affected drawable.
+ * @exposure: The exposure of the strokes.
+ * @dodgeburn_type: The type either dodge or burn.
+ * @dodgeburn_mode: The mode.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Dodgeburn image with varying exposure.
+ *
+ * Dodgeburn. More details here later.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_dodgeburn (gint32             drawable_ID,
+                 gdouble            exposure,
+                 GimpDodgeBurnType  dodgeburn_type,
+                 GimpTransferMode   dodgeburn_mode,
+                 gint               num_strokes,
+                 const gdouble     *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, exposure,
+                                          GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
+                                          GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-dodgeburn",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-dodgeburn",
+                                            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_dodgeburn_default:
+ * @drawable: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Dodgeburn image with varying exposure. This is the same as the
+ * gimp_dodgeburn() function except that the exposure, type and mode
+ * are taken from the tools option dialog. If the dialog has not been
+ * activated then the defaults as used by the dialog will be used.
+ *
+ * Dodgeburn. More details here later.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_dodgeburn_default (GimpDrawable  *drawable,
+                        gint           num_strokes,
+                        const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-dodgeburn-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-dodgeburn-default",
+                                            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_dodgeburn_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Dodgeburn image with varying exposure. This is the same as the
+ * gimp_dodgeburn() function except that the exposure, type and mode
+ * are taken from the tools option dialog. If the dialog has not been
+ * activated then the defaults as used by the dialog will be used.
+ *
+ * Dodgeburn. More details here later.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_dodgeburn_default (gint32         drawable_ID,
+                         gint           num_strokes,
+                         const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-dodgeburn-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-dodgeburn-default",
+                                            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_eraser:
+ * @drawable: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ * @hardness: How to apply the brush.
+ * @method: The paint method to use.
+ *
+ * Erase using the current brush.
+ *
+ * This tool erases using the current brush mask. If the specified
+ * drawable contains an alpha channel, then the erased pixels will
+ * become transparent. Otherwise, the eraser tool replaces the contents
+ * of the drawable with the background color. Like paintbrush, this
+ * tool linearly interpolates between the specified stroke coordinates.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_eraser (GimpDrawable             *drawable,
+             gint                      num_strokes,
+             const gdouble            *strokes,
+             GimpBrushApplicationMode  hardness,
+             GimpPaintApplicationMode  method)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
+                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-eraser",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-eraser",
+                                            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_eraser: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ * @hardness: How to apply the brush.
+ * @method: The paint method to use.
+ *
+ * Erase using the current brush.
+ *
+ * This tool erases using the current brush mask. If the specified
+ * drawable contains an alpha channel, then the erased pixels will
  * become transparent. Otherwise, the eraser tool replaces the contents
  * of the drawable with the background color. Like paintbrush, this
  * tool linearly interpolates between the specified stroke coordinates.
@@ -477,11 +956,337 @@ gimp_dodgeburn_default (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_eraser (gint32                    drawable_ID,
-             gint                      num_strokes,
-             const gdouble            *strokes,
-             GimpBrushApplicationMode  hardness,
-             GimpPaintApplicationMode  method)
+_gimp_eraser (gint32                    drawable_ID,
+              gint                      num_strokes,
+              const gdouble            *strokes,
+              GimpBrushApplicationMode  hardness,
+              GimpPaintApplicationMode  method)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
+                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-eraser",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-eraser",
+                                            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_eraser_default:
+ * @drawable: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Erase using the current brush.
+ *
+ * This tool erases using the current brush mask. This function
+ * performs exactly the same as the gimp_eraser() function except that
+ * the tools arguments are obtained from the eraser option dialog. It
+ * this dialog has not been activated then the dialogs default values
+ * will be used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_eraser_default (GimpDrawable  *drawable,
+                     gint           num_strokes,
+                     const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-eraser-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-eraser-default",
+                                            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_eraser_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Erase using the current brush.
+ *
+ * This tool erases using the current brush mask. This function
+ * performs exactly the same as the gimp_eraser() function except that
+ * the tools arguments are obtained from the eraser option dialog. It
+ * this dialog has not been activated then the dialogs default values
+ * will be used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_eraser_default (gint32         drawable_ID,
+                      gint           num_strokes,
+                      const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-eraser-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-eraser-default",
+                                            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_heal:
+ * @drawable: The affected drawable.
+ * @src_drawable: The source drawable.
+ * @src_x: The x coordinate in the source image.
+ * @src_y: The y coordinate in the source image.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Heal from the source to the dest drawable using the current brush
+ *
+ * This tool heals the source drawable starting at the specified source
+ * coordinates to the dest drawable. For image healing, if the sum of
+ * the src coordinates and subsequent stroke offsets exceeds the
+ * extents of the src drawable, then no paint is transferred. The
+ * healing tool is capable of transforming between any image types
+ * except RGB-&gt;Indexed.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_heal (GimpDrawable  *drawable,
+           GimpDrawable  *src_drawable,
+           gdouble        src_x,
+           gdouble        src_y,
+           gint           num_strokes,
+           const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (src_drawable)),
+                                          G_TYPE_DOUBLE, src_x,
+                                          G_TYPE_DOUBLE, src_y,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-heal",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-heal",
+                                            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_heal: (skip)
+ * @drawable_ID: The affected drawable.
+ * @src_drawable_ID: The source drawable.
+ * @src_x: The x coordinate in the source image.
+ * @src_y: The y coordinate in the source image.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Heal from the source to the dest drawable using the current brush
+ *
+ * This tool heals the source drawable starting at the specified source
+ * coordinates to the dest drawable. For image healing, if the sum of
+ * the src coordinates and subsequent stroke offsets exceeds the
+ * extents of the src drawable, then no paint is transferred. The
+ * healing tool is capable of transforming between any image types
+ * except RGB-&gt;Indexed.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_heal (gint32         drawable_ID,
+            gint32         src_drawable_ID,
+            gdouble        src_x,
+            gdouble        src_y,
+            gint           num_strokes,
+            const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
+                                          G_TYPE_DOUBLE, src_x,
+                                          G_TYPE_DOUBLE, src_y,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-heal",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-heal",
+                                            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_heal_default:
+ * @drawable: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Heal from the source to the dest drawable using the current brush
+ *
+ * This tool heals from the source drawable starting at the specified
+ * source coordinates to the dest drawable. This function performs
+ * exactly the same as the gimp_heal() function except that the tools
+ * arguments are obtained from the healing option dialog. It this
+ * dialog has not been activated then the dialogs default values will
+ * be used.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_heal_default (GimpDrawable  *drawable,
+                   gint           num_strokes,
+                   const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-heal-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-heal-default",
+                                            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_heal_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Heal from the source to the dest drawable using the current brush
+ *
+ * This tool heals from the source drawable starting at the specified
+ * source coordinates to the dest drawable. This function performs
+ * exactly the same as the gimp_heal() function except that the tools
+ * arguments are obtained from the healing option dialog. It this
+ * dialog has not been activated then the dialogs default values will
+ * be used.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.4
+ **/
+gboolean
+_gimp_heal_default (gint32         drawable_ID,
+                    gint           num_strokes,
+                    const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -492,17 +1297,78 @@ gimp_eraser (gint32                    drawable_ID,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
-                                          GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-heal-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-heal-default",
+                                            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_paintbrush:
+ * @drawable: The affected drawable.
+ * @fade_out: Fade out parameter.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ * @method: The paint method to use.
+ * @gradient_length: Length of gradient to draw.
+ *
+ * Paint in the current brush with optional fade out parameter and pull
+ * colors from a gradient.
+ *
+ * This tool is the standard paintbrush. It draws linearly interpolated
+ * lines through the specified stroke coordinates. It operates on the
+ * specified drawable in the foreground color with the active brush.
+ * The 'fade-out' parameter is measured in pixels and allows the brush
+ * stroke to linearly fall off. The pressure is set to the maximum at
+ * the beginning of the stroke. As the distance of the stroke nears the
+ * fade-out value, the pressure will approach zero. The gradient-length
+ * is the distance to spread the gradient over. It is measured in
+ * pixels. If the gradient-length is 0, no gradient is used.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+gimp_paintbrush (GimpDrawable             *drawable,
+                 gdouble                   fade_out,
+                 gint                      num_strokes,
+                 const gdouble            *strokes,
+                 GimpPaintApplicationMode  method,
+                 gdouble                   gradient_length)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, fade_out,
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           GIMP_TYPE_PAINT_APPLICATION_MODE, method,
+                                          G_TYPE_DOUBLE, gradient_length,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-eraser",
+                                                "gimp-paintbrush",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-eraser",
+    return_vals = gimp_run_procedure_array ("gimp-paintbrush",
                                             args);
   gimp_value_array_unref (args);
 
@@ -514,25 +1380,36 @@ gimp_eraser (gint32                    drawable_ID,
 }
 
 /**
- * gimp_eraser_default:
+ * _gimp_paintbrush: (skip)
  * @drawable_ID: The affected drawable.
+ * @fade_out: Fade out parameter.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ * @method: The paint method to use.
+ * @gradient_length: Length of gradient to draw.
  *
- * Erase using the current brush.
+ * Paint in the current brush with optional fade out parameter and pull
+ * colors from a gradient.
  *
- * This tool erases using the current brush mask. This function
- * performs exactly the same as the gimp_eraser() function except that
- * the tools arguments are obtained from the eraser option dialog. It
- * this dialog has not been activated then the dialogs default values
- * will be used.
+ * This tool is the standard paintbrush. It draws linearly interpolated
+ * lines through the specified stroke coordinates. It operates on the
+ * specified drawable in the foreground color with the active brush.
+ * The 'fade-out' parameter is measured in pixels and allows the brush
+ * stroke to linearly fall off. The pressure is set to the maximum at
+ * the beginning of the stroke. As the distance of the stroke nears the
+ * fade-out value, the pressure will approach zero. The gradient-length
+ * is the distance to spread the gradient over. It is measured in
+ * pixels. If the gradient-length is 0, no gradient is used.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_eraser_default (gint32         drawable_ID,
-                     gint           num_strokes,
-                     const gdouble *strokes)
+_gimp_paintbrush (gint32                    drawable_ID,
+                  gdouble                   fade_out,
+                  gint                      num_strokes,
+                  const gdouble            *strokes,
+                  GimpPaintApplicationMode  method,
+                  gdouble                   gradient_length)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -541,17 +1418,20 @@ gimp_eraser_default (gint32         drawable_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, fade_out,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
+                                          G_TYPE_DOUBLE, gradient_length,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-eraser-default",
+                                                "gimp-paintbrush",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-eraser-default",
+    return_vals = gimp_run_procedure_array ("gimp-paintbrush",
                                             args);
   gimp_value_array_unref (args);
 
@@ -563,34 +1443,34 @@ gimp_eraser_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_heal:
- * @drawable_ID: The affected drawable.
- * @src_drawable_ID: The source drawable.
- * @src_x: The x coordinate in the source image.
- * @src_y: The y coordinate in the source image.
+ * gimp_paintbrush_default:
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Heal from the source to the dest drawable using the current brush
+ * Paint in the current brush. The fade out parameter and pull colors
+ * from a gradient parameter are set from the paintbrush options
+ * dialog. If this dialog has not been activated then the dialog
+ * defaults will be used.
  *
- * This tool heals the source drawable starting at the specified source
- * coordinates to the dest drawable. For image healing, if the sum of
- * the src coordinates and subsequent stroke offsets exceeds the
- * extents of the src drawable, then no paint is transferred. The
- * healing tool is capable of transforming between any image types
- * except RGB-&gt;Indexed.
+ * This tool is similar to the standard paintbrush. It draws linearly
+ * interpolated lines through the specified stroke coordinates. It
+ * operates on the specified drawable in the foreground color with the
+ * active brush. The 'fade-out' parameter is measured in pixels and
+ * allows the brush stroke to linearly fall off (value obtained from
+ * the option dialog). The pressure is set to the maximum at the
+ * beginning of the stroke. As the distance of the stroke nears the
+ * fade-out value, the pressure will approach zero. The gradient-length
+ * (value obtained from the option dialog) is the distance to spread
+ * the gradient over. It is measured in pixels. If the gradient-length
+ * is 0, no gradient is used.
  *
  * Returns: TRUE on success.
- *
- * Since: 2.4
  **/
 gboolean
-gimp_heal (gint32         drawable_ID,
-           gint32         src_drawable_ID,
-           gdouble        src_x,
-           gdouble        src_y,
-           gint           num_strokes,
-           const gdouble *strokes)
+gimp_paintbrush_default (GimpDrawable  *drawable,
+                         gint           num_strokes,
+                         const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -598,21 +1478,18 @@ gimp_heal (gint32         drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
-                                          G_TYPE_DOUBLE, src_x,
-                                          G_TYPE_DOUBLE, src_y,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-heal",
+                                                "gimp-paintbrush-default",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-heal",
+    return_vals = gimp_run_procedure_array ("gimp-paintbrush-default",
                                             args);
   gimp_value_array_unref (args);
 
@@ -624,28 +1501,34 @@ gimp_heal (gint32         drawable_ID,
 }
 
 /**
- * gimp_heal_default:
+ * _gimp_paintbrush_default: (skip)
  * @drawable_ID: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Heal from the source to the dest drawable using the current brush
+ * Paint in the current brush. The fade out parameter and pull colors
+ * from a gradient parameter are set from the paintbrush options
+ * dialog. If this dialog has not been activated then the dialog
+ * defaults will be used.
  *
- * This tool heals from the source drawable starting at the specified
- * source coordinates to the dest drawable. This function performs
- * exactly the same as the gimp_heal() function except that the tools
- * arguments are obtained from the healing option dialog. It this
- * dialog has not been activated then the dialogs default values will
- * be used.
+ * This tool is similar to the standard paintbrush. It draws linearly
+ * interpolated lines through the specified stroke coordinates. It
+ * operates on the specified drawable in the foreground color with the
+ * active brush. The 'fade-out' parameter is measured in pixels and
+ * allows the brush stroke to linearly fall off (value obtained from
+ * the option dialog). The pressure is set to the maximum at the
+ * beginning of the stroke. As the distance of the stroke nears the
+ * fade-out value, the pressure will approach zero. The gradient-length
+ * (value obtained from the option dialog) is the distance to spread
+ * the gradient over. It is measured in pixels. If the gradient-length
+ * is 0, no gradient is used.
  *
  * Returns: TRUE on success.
- *
- * Since: 2.4
  **/
 gboolean
-gimp_heal_default (gint32         drawable_ID,
-                   gint           num_strokes,
-                   const gdouble *strokes)
+_gimp_paintbrush_default (gint32         drawable_ID,
+                          gint           num_strokes,
+                          const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -661,10 +1544,10 @@ gimp_heal_default (gint32         drawable_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-heal-default",
+                                                "gimp-paintbrush-default",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-heal-default",
+    return_vals = gimp_run_procedure_array ("gimp-paintbrush-default",
                                             args);
   gimp_value_array_unref (args);
 
@@ -676,36 +1559,26 @@ gimp_heal_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_paintbrush:
- * @drawable_ID: The affected drawable.
- * @fade_out: Fade out parameter.
+ * gimp_pencil:
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
- * @method: The paint method to use.
- * @gradient_length: Length of gradient to draw.
  *
- * Paint in the current brush with optional fade out parameter and pull
- * colors from a gradient.
+ * Paint in the current brush without sub-pixel sampling.
  *
- * This tool is the standard paintbrush. It draws linearly interpolated
+ * This tool is the standard pencil. It draws linearly interpolated
  * lines through the specified stroke coordinates. It operates on the
  * specified drawable in the foreground color with the active brush.
- * The 'fade-out' parameter is measured in pixels and allows the brush
- * stroke to linearly fall off. The pressure is set to the maximum at
- * the beginning of the stroke. As the distance of the stroke nears the
- * fade-out value, the pressure will approach zero. The gradient-length
- * is the distance to spread the gradient over. It is measured in
- * pixels. If the gradient-length is 0, no gradient is used.
+ * The brush mask is treated as though it contains only black and white
+ * values. Any value below half is treated as black; any above half, as
+ * white.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_paintbrush (gint32                    drawable_ID,
-                 gdouble                   fade_out,
-                 gint                      num_strokes,
-                 const gdouble            *strokes,
-                 GimpPaintApplicationMode  method,
-                 gdouble                   gradient_length)
+gimp_pencil (GimpDrawable  *drawable,
+             gint           num_strokes,
+             const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -713,21 +1586,18 @@ gimp_paintbrush (gint32                    drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_DOUBLE, fade_out,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
-                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
-                                          G_TYPE_DOUBLE, gradient_length,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-paintbrush",
+                                                "gimp-pencil",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-paintbrush",
+    return_vals = gimp_run_procedure_array ("gimp-pencil",
                                             args);
   gimp_value_array_unref (args);
 
@@ -739,34 +1609,26 @@ gimp_paintbrush (gint32                    drawable_ID,
 }
 
 /**
- * gimp_paintbrush_default:
+ * _gimp_pencil: (skip)
  * @drawable_ID: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Paint in the current brush. The fade out parameter and pull colors
- * from a gradient parameter are set from the paintbrush options
- * dialog. If this dialog has not been activated then the dialog
- * defaults will be used.
+ * Paint in the current brush without sub-pixel sampling.
  *
- * This tool is similar to the standard paintbrush. It draws linearly
- * interpolated lines through the specified stroke coordinates. It
- * operates on the specified drawable in the foreground color with the
- * active brush. The 'fade-out' parameter is measured in pixels and
- * allows the brush stroke to linearly fall off (value obtained from
- * the option dialog). The pressure is set to the maximum at the
- * beginning of the stroke. As the distance of the stroke nears the
- * fade-out value, the pressure will approach zero. The gradient-length
- * (value obtained from the option dialog) is the distance to spread
- * the gradient over. It is measured in pixels. If the gradient-length
- * is 0, no gradient is used.
+ * This tool is the standard pencil. It draws linearly interpolated
+ * lines through the specified stroke coordinates. It operates on the
+ * specified drawable in the foreground color with the active brush.
+ * The brush mask is treated as though it contains only black and white
+ * values. Any value below half is treated as black; any above half, as
+ * white.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_paintbrush_default (gint32         drawable_ID,
-                         gint           num_strokes,
-                         const gdouble *strokes)
+_gimp_pencil (gint32         drawable_ID,
+              gint           num_strokes,
+              const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -782,10 +1644,10 @@ gimp_paintbrush_default (gint32         drawable_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-paintbrush-default",
+                                                "gimp-pencil",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-paintbrush-default",
+    return_vals = gimp_run_procedure_array ("gimp-pencil",
                                             args);
   gimp_value_array_unref (args);
 
@@ -797,24 +1659,23 @@ gimp_paintbrush_default (gint32         drawable_ID,
 }
 
 /**
- * gimp_pencil:
- * @drawable_ID: The affected drawable.
+ * gimp_smudge:
+ * @drawable: The affected drawable.
+ * @pressure: The pressure of the smudge strokes.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
- * Paint in the current brush without sub-pixel sampling.
+ * Smudge image with varying pressure.
  *
- * This tool is the standard pencil. It draws linearly interpolated
- * lines through the specified stroke coordinates. It operates on the
- * specified drawable in the foreground color with the active brush.
- * The brush mask is treated as though it contains only black and white
- * values. Any value below half is treated as black; any above half, as
- * white.
+ * This tool simulates a smudge using the current brush. High pressure
+ * results in a greater smudge of paint while low pressure results in a
+ * lesser smudge.
  *
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_pencil (gint32         drawable_ID,
+gimp_smudge (GimpDrawable  *drawable,
+             gdouble        pressure,
              gint           num_strokes,
              const gdouble *strokes)
 {
@@ -824,18 +1685,19 @@ gimp_pencil (gint32         drawable_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_DOUBLE, pressure,
                                           G_TYPE_INT, num_strokes,
                                           GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+  gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-pencil",
+                                                "gimp-smudge",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-pencil",
+    return_vals = gimp_run_procedure_array ("gimp-smudge",
                                             args);
   gimp_value_array_unref (args);
 
@@ -847,7 +1709,7 @@ gimp_pencil (gint32         drawable_ID,
 }
 
 /**
- * gimp_smudge:
+ * _gimp_smudge: (skip)
  * @drawable_ID: The affected drawable.
  * @pressure: The pressure of the smudge strokes.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
@@ -862,10 +1724,10 @@ gimp_pencil (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_smudge (gint32         drawable_ID,
-             gdouble        pressure,
-             gint           num_strokes,
-             const gdouble *strokes)
+_gimp_smudge (gint32         drawable_ID,
+              gdouble        pressure,
+              gint           num_strokes,
+              const gdouble *strokes)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -898,7 +1760,7 @@ gimp_smudge (gint32         drawable_ID,
 
 /**
  * gimp_smudge_default:
- * @drawable_ID: The affected drawable.
+ * @drawable: The affected drawable.
  * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
  * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
  *
@@ -912,7 +1774,7 @@ gimp_smudge (gint32         drawable_ID,
  * Returns: TRUE on success.
  **/
 gboolean
-gimp_smudge_default (gint32         drawable_ID,
+gimp_smudge_default (GimpDrawable  *drawable,
                      gint           num_strokes,
                      const gdouble *strokes)
 {
@@ -921,6 +1783,54 @@ gimp_smudge_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          G_TYPE_INT, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_NONE);
+  gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-smudge-default",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-smudge-default",
+                                            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_smudge_default: (skip)
+ * @drawable_ID: The affected drawable.
+ * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
+ * @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, 
s2.x, s2.y, ..., sn.x, sn.y }.
+ *
+ * Smudge image with varying pressure.
+ *
+ * This tool simulates a smudge using the current brush. It behaves
+ * exactly the same as gimp_smudge() except that the pressure value is
+ * taken from the smudge tool options or the options default if the
+ * tools option dialog has not been activated.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_smudge_default (gint32         drawable_ID,
+                      gint           num_strokes,
+                      const gdouble *strokes)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_INT, num_strokes,
diff --git a/libgimp/gimppainttools_pdb.h b/libgimp/gimppainttools_pdb.h
index b2c1d9b17b..ec648c32ae 100644
--- a/libgimp/gimppainttools_pdb.h
+++ b/libgimp/gimppainttools_pdb.h
@@ -32,83 +32,100 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gboolean gimp_airbrush           (gint32                    drawable_ID,
+
+
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
+
+gboolean gimp_airbrush           (GimpDrawable             *drawable,
                                   gdouble                   pressure,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_airbrush_default   (gint32                    drawable_ID,
+gboolean gimp_airbrush_default   (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_clone              (gint32                    drawable_ID,
-                                  gint32                    src_drawable_ID,
+gboolean gimp_clone              (GimpDrawable             *drawable,
+                                  GimpDrawable             *src_drawable,
                                   GimpCloneType             clone_type,
                                   gdouble                   src_x,
                                   gdouble                   src_y,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_clone_default      (gint32                    drawable_ID,
+gboolean gimp_clone_default      (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_convolve           (gint32                    drawable_ID,
+gboolean gimp_convolve           (GimpDrawable             *drawable,
                                   gdouble                   pressure,
                                   GimpConvolveType          convolve_type,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_convolve_default   (gint32                    drawable_ID,
+gboolean gimp_convolve_default   (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_dodgeburn          (gint32                    drawable_ID,
+gboolean gimp_dodgeburn          (GimpDrawable             *drawable,
                                   gdouble                   exposure,
                                   GimpDodgeBurnType         dodgeburn_type,
                                   GimpTransferMode          dodgeburn_mode,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_dodgeburn_default  (gint32                    drawable_ID,
+gboolean gimp_dodgeburn_default  (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_eraser             (gint32                    drawable_ID,
+gboolean gimp_eraser             (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes,
                                   GimpBrushApplicationMode  hardness,
                                   GimpPaintApplicationMode  method);
-gboolean gimp_eraser_default     (gint32                    drawable_ID,
+gboolean gimp_eraser_default     (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_heal               (gint32                    drawable_ID,
-                                  gint32                    src_drawable_ID,
+gboolean gimp_heal               (GimpDrawable             *drawable,
+                                  GimpDrawable             *src_drawable,
                                   gdouble                   src_x,
                                   gdouble                   src_y,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_heal_default       (gint32                    drawable_ID,
+gboolean gimp_heal_default       (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_paintbrush         (gint32                    drawable_ID,
+gboolean gimp_paintbrush         (GimpDrawable             *drawable,
                                   gdouble                   fade_out,
                                   gint                      num_strokes,
                                   const gdouble            *strokes,
                                   GimpPaintApplicationMode  method,
                                   gdouble                   gradient_length);
-gboolean gimp_paintbrush_default (gint32                    drawable_ID,
+gboolean gimp_paintbrush_default (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_pencil             (gint32                    drawable_ID,
+gboolean gimp_pencil             (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_smudge             (gint32                    drawable_ID,
+gboolean gimp_smudge             (GimpDrawable             *drawable,
                                   gdouble                   pressure,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
-gboolean gimp_smudge_default     (gint32                    drawable_ID,
+gboolean gimp_smudge_default     (GimpDrawable             *drawable,
                                   gint                      num_strokes,
                                   const gdouble            *strokes);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
-
-
-
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
+#define gimp_airbrush _gimp_airbrush
+#define gimp_airbrush_default _gimp_airbrush_default
+#define gimp_clone _gimp_clone
+#define gimp_clone_default _gimp_clone_default
+#define gimp_convolve _gimp_convolve
+#define gimp_convolve_default _gimp_convolve_default
+#define gimp_dodgeburn _gimp_dodgeburn
+#define gimp_dodgeburn_default _gimp_dodgeburn_default
+#define gimp_eraser _gimp_eraser
+#define gimp_eraser_default _gimp_eraser_default
+#define gimp_heal _gimp_heal
+#define gimp_heal_default _gimp_heal_default
+#define gimp_paintbrush _gimp_paintbrush
+#define gimp_paintbrush_default _gimp_paintbrush_default
+#define gimp_pencil _gimp_pencil
+#define gimp_smudge _gimp_smudge
+#define gimp_smudge_default _gimp_smudge_default
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -117,7 +134,76 @@ gboolean gimp_smudge_default     (gint32                    drawable_ID,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-
+gboolean _gimp_airbrush           (gint32                    drawable_ID,
+                                   gdouble                   pressure,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_airbrush_default   (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_clone              (gint32                    drawable_ID,
+                                   gint32                    src_drawable_ID,
+                                   GimpCloneType             clone_type,
+                                   gdouble                   src_x,
+                                   gdouble                   src_y,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_clone_default      (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_convolve           (gint32                    drawable_ID,
+                                   gdouble                   pressure,
+                                   GimpConvolveType          convolve_type,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_convolve_default   (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_dodgeburn          (gint32                    drawable_ID,
+                                   gdouble                   exposure,
+                                   GimpDodgeBurnType         dodgeburn_type,
+                                   GimpTransferMode          dodgeburn_mode,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_dodgeburn_default  (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_eraser             (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes,
+                                   GimpBrushApplicationMode  hardness,
+                                   GimpPaintApplicationMode  method);
+gboolean _gimp_eraser_default     (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_heal               (gint32                    drawable_ID,
+                                   gint32                    src_drawable_ID,
+                                   gdouble                   src_x,
+                                   gdouble                   src_y,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_heal_default       (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_paintbrush         (gint32                    drawable_ID,
+                                   gdouble                   fade_out,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes,
+                                   GimpPaintApplicationMode  method,
+                                   gdouble                   gradient_length);
+gboolean _gimp_paintbrush_default (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_pencil             (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_smudge             (gint32                    drawable_ID,
+                                   gdouble                   pressure,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
+gboolean _gimp_smudge_default     (gint32                    drawable_ID,
+                                   gint                      num_strokes,
+                                   const gdouble            *strokes);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index ff61666190..bfdd3e315e 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -444,6 +444,56 @@ _gimp_selection_translate (gint32 image_ID,
 
 /**
  * _gimp_selection_float:
+ * @drawable: 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: (transfer full): The floated layer.
+ **/
+GimpLayer *
+_gimp_selection_float (GimpDrawable *drawable,
+                       gint          offx,
+                       gint          offy)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpLayer *layer = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
+                                          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 = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
+
+  gimp_value_array_unref (return_vals);
+
+  return layer;
+}
+
+/**
+ * __gimp_selection_float: (skip)
  * @drawable_ID: The drawable from which to float selection.
  * @offx: x offset for translation.
  * @offy: y offset for translation.
@@ -460,9 +510,9 @@ _gimp_selection_translate (gint32 image_ID,
  * Returns: The floated layer.
  **/
 gint32
-_gimp_selection_float (gint32 drawable_ID,
-                       gint   offx,
-                       gint   offy)
+__gimp_selection_float (gint32 drawable_ID,
+                        gint   offx,
+                        gint   offy)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h
index 387952d365..62e190e295 100644
--- a/libgimp/gimpselection_pdb.h
+++ b/libgimp/gimpselection_pdb.h
@@ -32,39 +32,40 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-G_GNUC_INTERNAL gint32 _gimp_selection_float (gint32 drawable_ID,
-                                              gint   offx,
-                                              gint   offy);
+
 
 #ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
-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);
-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);
+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 GimpLayer* _gimp_selection_float    (GimpDrawable *drawable,
+                                                     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);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
@@ -72,6 +73,7 @@ gint32   gimp_selection_save      (GimpImage *image);
 #define gimp_selection_value _gimp_selection_value
 #define gimp_selection_is_empty _gimp_selection_is_empty
 #define gimp_selection_translate _gimp_selection_translate
+#define _gimp_selection_float __gimp_selection_float
 #define gimp_selection_invert _gimp_selection_invert
 #define gimp_selection_sharpen _gimp_selection_sharpen
 #define gimp_selection_all _gimp_selection_all
@@ -103,6 +105,9 @@ gboolean _gimp_selection_is_empty  (gint32    image_ID);
 gboolean _gimp_selection_translate (gint32    image_ID,
                                     gint      offx,
                                     gint      offy);
+gint32   __gimp_selection_float    (gint32    drawable_ID,
+                                    gint      offx,
+                                    gint      offy);
 gboolean _gimp_selection_invert    (gint32    image_ID);
 gboolean _gimp_selection_sharpen   (gint32    image_ID);
 gboolean _gimp_selection_all       (gint32    image_ID);
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index c2082de921..098b6db778 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -51,11 +51,11 @@
  * added to the image, as this is not automatic. Add the new layer
  * using gimp_image_insert_layer().
  *
- * Returns: The new text layer.
+ * Returns: (transfer full): The new text layer.
  *
  * Since: 2.6
  **/
-gint32
+GimpLayer *
 gimp_text_layer_new (GimpImage   *image,
                      const gchar *text,
                      const gchar *fontname,
@@ -65,7 +65,7 @@ gimp_text_layer_new (GimpImage   *image,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
+  GimpLayer *layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
@@ -85,11 +85,11 @@ gimp_text_layer_new (GimpImage   *image,
   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));
+    layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index (return_vals, 
1))));
 
   gimp_value_array_unref (return_vals);
 
-  return layer_ID;
+  return layer;
 }
 
 /**
@@ -152,7 +152,7 @@ _gimp_text_layer_new (gint32       image_ID,
 
 /**
  * gimp_text_layer_get_text:
- * @layer_ID: The text layer.
+ * @layer: The text layer.
  *
  * Get the text from a text layer as string.
  *
@@ -164,7 +164,49 @@ _gimp_text_layer_new (gint32       image_ID,
  * Since: 2.6
  **/
 gchar *
-gimp_text_layer_get_text (gint32 layer_ID)
+gimp_text_layer_get_text (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *text = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-text",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-text",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    text = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return text;
+}
+
+/**
+ * _gimp_text_layer_get_text: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Get the text from a text layer as string.
+ *
+ * This procedure returns the text from a text layer as a string.
+ *
+ * Returns: The text from the specified text layer.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.6
+ **/
+gchar *
+_gimp_text_layer_get_text (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -194,7 +236,7 @@ gimp_text_layer_get_text (gint32 layer_ID)
 
 /**
  * gimp_text_layer_set_text:
- * @layer_ID: The text layer.
+ * @layer: The text layer.
  * @text: The new text to set.
  *
  * Set the text of a text layer.
@@ -206,7 +248,7 @@ gimp_text_layer_get_text (gint32 layer_ID)
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_text (gint32       layer_ID,
+gimp_text_layer_set_text (GimpLayer   *layer,
                           const gchar *text)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
@@ -214,6 +256,49 @@ gimp_text_layer_set_text (gint32       layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_STRING, text,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-text",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-text",
+                                            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_text_layer_set_text: (skip)
+ * @layer_ID: The text layer.
+ * @text: The new text to set.
+ *
+ * Set the text of a text layer.
+ *
+ * This procedure changes the text of a text layer.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_text (gint32       layer_ID,
+                           const gchar *text)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_STRING, text,
@@ -237,7 +322,7 @@ gimp_text_layer_set_text (gint32       layer_ID,
 
 /**
  * gimp_text_layer_get_markup:
- * @layer_ID: The text layer.
+ * @layer: The text layer.
  *
  * Get the markup from a text layer as string.
  *
@@ -254,7 +339,7 @@ gimp_text_layer_set_text (gint32       layer_ID,
  * Since: 2.8
  **/
 gchar *
-gimp_text_layer_get_markup (gint32 layer_ID)
+gimp_text_layer_get_markup (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -262,7 +347,7 @@ gimp_text_layer_get_markup (gint32 layer_ID)
   gchar *markup = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
@@ -283,26 +368,29 @@ gimp_text_layer_get_markup (gint32 layer_ID)
 }
 
 /**
- * gimp_text_layer_get_font:
+ * _gimp_text_layer_get_markup: (skip)
  * @layer_ID: The text layer.
  *
- * Get the font from a text layer as string.
+ * Get the markup from a text layer as string.
  *
- * This procedure returns the name of the font from a text layer.
+ * This procedure returns the markup of the styles from a text layer.
+ * The markup will be in the form of Pango's markup - See
+ * https://www.pango.org/ for more information about Pango and its
+ * markup. Note: Setting the markup of a text layer using Pango's
+ * markup is not supported for now.
  *
- * Returns: (transfer full):
- *          The font which is used in the specified text layer.
+ * Returns: The markup which represents the style of the specified text layer.
  *          The returned value must be freed with g_free().
  *
- * Since: 2.6
+ * Since: 2.8
  **/
 gchar *
-gimp_text_layer_get_font (gint32 layer_ID)
+_gimp_text_layer_get_markup (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *font = NULL;
+  gchar *markup = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -310,87 +398,84 @@ gimp_text_layer_get_font (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-font",
+                                                "gimp-text-layer-get-markup",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-markup",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    font = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+    markup = g_value_dup_string (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return font;
+  return markup;
 }
 
 /**
- * gimp_text_layer_set_font:
- * @layer_ID: The text layer.
- * @font: The new font to use.
+ * gimp_text_layer_get_font:
+ * @layer: The text layer.
  *
- * Set the font of a text layer.
+ * Get the font from a text layer as string.
  *
- * This procedure modifies the font used in the specified text layer.
+ * This procedure returns the name of the font from a text layer.
  *
- * Returns: TRUE on success.
+ * Returns: (transfer full):
+ *          The font which is used in the specified text layer.
+ *          The returned value must be freed with g_free().
  *
  * Since: 2.6
  **/
-gboolean
-gimp_text_layer_set_font (gint32       layer_ID,
-                          const gchar *font)
+gchar *
+gimp_text_layer_get_font (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gchar *font = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_STRING, font,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-font",
+                                                "gimp-text-layer-get-font",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font",
                                             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)
+    font = g_value_dup_string (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return font;
 }
 
 /**
- * gimp_text_layer_get_font_size:
+ * _gimp_text_layer_get_font: (skip)
  * @layer_ID: The text layer.
- * @unit: (out) (transfer none): The unit used for the font size.
  *
- * Get the font size from a text layer.
+ * Get the font from a text layer as string.
  *
- * This procedure returns the size of the font which is used in a text
- * layer. You will receive the size as a float 'font-size' in 'unit'
- * units.
+ * This procedure returns the name of the font from a text layer.
  *
- * Returns: The font size.
+ * Returns: The font which is used in the specified text layer.
+ *          The returned value must be freed with g_free().
  *
  * Since: 2.6
  **/
-gdouble
-gimp_text_layer_get_font_size (gint32    layer_ID,
-                               GimpUnit *unit)
+gchar *
+_gimp_text_layer_get_font (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gdouble font_size = 0.0;
+  gchar *font = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -398,43 +483,37 @@ gimp_text_layer_get_font_size (gint32    layer_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-font-size",
+                                                "gimp-text-layer-get-font",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font-size",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      font_size = g_value_get_double (gimp_value_array_index (return_vals, 1));
-      *unit = g_value_get_int (gimp_value_array_index (return_vals, 2));
-    }
+    font = g_value_dup_string (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return font_size;
+  return font;
 }
 
 /**
- * gimp_text_layer_set_font_size:
- * @layer_ID: The text layer.
- * @font_size: The font size.
- * @unit: The unit to use for the font size.
+ * gimp_text_layer_set_font:
+ * @layer: The text layer.
+ * @font: The new font to use.
  *
- * Set the font size.
+ * Set the font of a text layer.
  *
- * This procedure changes the font size of a text layer. The size of
- * your font will be a double 'font-size' of 'unit' units.
+ * This procedure modifies the font used in the specified text layer.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_font_size (gint32   layer_ID,
-                               gdouble  font_size,
-                               GimpUnit unit)
+gimp_text_layer_set_font (GimpLayer   *layer,
+                          const gchar *font)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -442,17 +521,16 @@ gimp_text_layer_set_font_size (gint32   layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_DOUBLE, font_size,
-                                          GIMP_TYPE_UNIT, unit,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_STRING, font,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-font-size",
+                                                "gimp-text-layer-set-font",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font-size",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font",
                                             args);
   gimp_value_array_unref (args);
 
@@ -464,112 +542,119 @@ gimp_text_layer_set_font_size (gint32   layer_ID,
 }
 
 /**
- * gimp_text_layer_get_antialias:
+ * _gimp_text_layer_set_font: (skip)
  * @layer_ID: The text layer.
+ * @font: The new font to use.
  *
- * Check if antialiasing is used in the text layer.
+ * Set the font of a text layer.
  *
- * This procedure checks if antialiasing is enabled in the specified
- * text layer.
+ * This procedure modifies the font used in the specified text layer.
  *
- * Returns: A flag which is true if antialiasing is used for rendering the font in the text layer.
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_get_antialias (gint32 layer_ID)
+_gimp_text_layer_set_font (gint32       layer_ID,
+                           const gchar *font)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean antialias = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_STRING, font,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-antialias",
+                                                "gimp-text-layer-set-font",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-antialias",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    antialias = 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 antialias;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_antialias:
- * @layer_ID: The text layer.
- * @antialias: Enable/disable antialiasing of the text.
+ * gimp_text_layer_get_font_size:
+ * @layer: The text layer.
+ * @unit: (out) (transfer none): The unit used for the font size.
  *
- * Enable/disable anti-aliasing in a text layer.
+ * Get the font size from a text layer.
  *
- * This procedure enables or disables anti-aliasing of the text in a
- * text layer.
+ * This procedure returns the size of the font which is used in a text
+ * layer. You will receive the size as a float 'font-size' in 'unit'
+ * units.
  *
- * Returns: TRUE on success.
+ * Returns: The font size.
  *
  * Since: 2.6
  **/
-gboolean
-gimp_text_layer_set_antialias (gint32   layer_ID,
-                               gboolean antialias)
+gdouble
+gimp_text_layer_get_font_size (GimpLayer *layer,
+                               GimpUnit  *unit)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gdouble font_size = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, antialias,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-antialias",
+                                                "gimp-text-layer-get-font-size",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-antialias",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font-size",
                                             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)
+    {
+      font_size = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *unit = g_value_get_int (gimp_value_array_index (return_vals, 2));
+    }
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return font_size;
 }
 
 /**
- * gimp_text_layer_get_hint_style:
+ * _gimp_text_layer_get_font_size: (skip)
  * @layer_ID: The text layer.
+ * @unit: (out): The unit used for the font size.
  *
- * Get information about hinting in the specified text layer.
+ * Get the font size from a text layer.
  *
- * This procedure provides information about the hinting that is being
- * used in a text layer. Hinting can be optimized for fidelity or
- * contrast or it can be turned entirely off.
+ * This procedure returns the size of the font which is used in a text
+ * layer. You will receive the size as a float 'font-size' in 'unit'
+ * units.
  *
- * Returns: The hint style used for font outlines.
+ * Returns: The font size.
  *
- * Since: 2.8
+ * Since: 2.6
  **/
-GimpTextHintStyle
-gimp_text_layer_get_hint_style (gint32 layer_ID)
+gdouble
+_gimp_text_layer_get_font_size (gint32    layer_ID,
+                                GimpUnit *unit)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpTextHintStyle style = 0;
+  gdouble font_size = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -577,10 +662,322 @@ gimp_text_layer_get_hint_style (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-hint-style",
+                                                "gimp-text-layer-get-font-size",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-hint-style",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font-size",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    {
+      font_size = g_value_get_double (gimp_value_array_index (return_vals, 1));
+      *unit = g_value_get_int (gimp_value_array_index (return_vals, 2));
+    }
+
+  gimp_value_array_unref (return_vals);
+
+  return font_size;
+}
+
+/**
+ * gimp_text_layer_set_font_size:
+ * @layer: The text layer.
+ * @font_size: The font size.
+ * @unit: The unit to use for the font size.
+ *
+ * Set the font size.
+ *
+ * This procedure changes the font size of a text layer. The size of
+ * your font will be a double 'font-size' of 'unit' units.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_font_size (GimpLayer *layer,
+                               gdouble    font_size,
+                               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_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, font_size,
+                                          GIMP_TYPE_UNIT, unit,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-font-size",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font-size",
+                                            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_text_layer_set_font_size: (skip)
+ * @layer_ID: The text layer.
+ * @font_size: The font size.
+ * @unit: The unit to use for the font size.
+ *
+ * Set the font size.
+ *
+ * This procedure changes the font size of a text layer. The size of
+ * your font will be a double 'font-size' of 'unit' units.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_font_size (gint32   layer_ID,
+                                gdouble  font_size,
+                                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_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, font_size,
+                                          GIMP_TYPE_UNIT, unit,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-font-size",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font-size",
+                                            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_text_layer_get_antialias:
+ * @layer: The text layer.
+ *
+ * Check if antialiasing is used in the text layer.
+ *
+ * This procedure checks if antialiasing is enabled in the specified
+ * text layer.
+ *
+ * Returns: A flag which is true if antialiasing is used for rendering the font in the text layer.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_get_antialias (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean antialias = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-antialias",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-antialias",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    antialias = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return antialias;
+}
+
+/**
+ * _gimp_text_layer_get_antialias: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Check if antialiasing is used in the text layer.
+ *
+ * This procedure checks if antialiasing is enabled in the specified
+ * text layer.
+ *
+ * Returns: A flag which is true if antialiasing is used for rendering the font in the text layer.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_get_antialias (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean antialias = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-antialias",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-antialias",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    antialias = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return antialias;
+}
+
+/**
+ * gimp_text_layer_set_antialias:
+ * @layer: The text layer.
+ * @antialias: Enable/disable antialiasing of the text.
+ *
+ * Enable/disable anti-aliasing in a text layer.
+ *
+ * This procedure enables or disables anti-aliasing of the text in a
+ * text layer.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_antialias (GimpLayer *layer,
+                               gboolean   antialias)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, antialias,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-antialias",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-antialias",
+                                            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_text_layer_set_antialias: (skip)
+ * @layer_ID: The text layer.
+ * @antialias: Enable/disable antialiasing of the text.
+ *
+ * Enable/disable anti-aliasing in a text layer.
+ *
+ * This procedure enables or disables anti-aliasing of the text in a
+ * text layer.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_antialias (gint32   layer_ID,
+                                gboolean antialias)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, antialias,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-antialias",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-antialias",
+                                            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_text_layer_get_hint_style:
+ * @layer: The text layer.
+ *
+ * Get information about hinting in the specified text layer.
+ *
+ * This procedure provides information about the hinting that is being
+ * used in a text layer. Hinting can be optimized for fidelity or
+ * contrast or it can be turned entirely off.
+ *
+ * Returns: The hint style used for font outlines.
+ *
+ * Since: 2.8
+ **/
+GimpTextHintStyle
+gimp_text_layer_get_hint_style (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextHintStyle style = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-hint-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-hint-style",
                                             args);
   gimp_value_array_unref (args);
 
@@ -589,27 +986,759 @@ gimp_text_layer_get_hint_style (gint32 layer_ID)
 
   gimp_value_array_unref (return_vals);
 
-  return style;
+  return style;
+}
+
+/**
+ * _gimp_text_layer_get_hint_style: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Get information about hinting in the specified text layer.
+ *
+ * This procedure provides information about the hinting that is being
+ * used in a text layer. Hinting can be optimized for fidelity or
+ * contrast or it can be turned entirely off.
+ *
+ * Returns: The hint style used for font outlines.
+ *
+ * Since: 2.8
+ **/
+GimpTextHintStyle
+_gimp_text_layer_get_hint_style (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextHintStyle style = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-hint-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-hint-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_text_layer_set_hint_style:
+ * @layer: The text layer.
+ * @style: The new hint style.
+ *
+ * Control how font outlines are hinted in a text layer.
+ *
+ * This procedure sets the hint style for font outlines in a text
+ * layer. This controls whether to fit font outlines to the pixel grid,
+ * and if so, whether to optimize for fidelity or contrast.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_text_layer_set_hint_style (GimpLayer         *layer,
+                                GimpTextHintStyle  style)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_TEXT_HINT_STYLE, style,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-hint-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-hint-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;
+}
+
+/**
+ * _gimp_text_layer_set_hint_style: (skip)
+ * @layer_ID: The text layer.
+ * @style: The new hint style.
+ *
+ * Control how font outlines are hinted in a text layer.
+ *
+ * This procedure sets the hint style for font outlines in a text
+ * layer. This controls whether to fit font outlines to the pixel grid,
+ * and if so, whether to optimize for fidelity or contrast.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.8
+ **/
+gboolean
+_gimp_text_layer_set_hint_style (gint32            layer_ID,
+                                 GimpTextHintStyle style)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_HINT_STYLE, style,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-hint-style",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-hint-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;
+}
+
+/**
+ * gimp_text_layer_get_kerning:
+ * @layer: The text layer.
+ *
+ * Check if kerning is used in the text layer.
+ *
+ * This procedure checks if kerning is enabled in the specified text
+ * layer.
+ *
+ * Returns: A flag which is true if kerning is used in the text layer.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_get_kerning (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean kerning = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-kerning",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-kerning",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    kerning = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return kerning;
+}
+
+/**
+ * _gimp_text_layer_get_kerning: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Check if kerning is used in the text layer.
+ *
+ * This procedure checks if kerning is enabled in the specified text
+ * layer.
+ *
+ * Returns: A flag which is true if kerning is used in the text layer.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_get_kerning (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean kerning = FALSE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-kerning",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-kerning",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    kerning = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return kerning;
+}
+
+/**
+ * gimp_text_layer_set_kerning:
+ * @layer: The text layer.
+ * @kerning: Enable/disable kerning in the text.
+ *
+ * Enable/disable kerning in a text layer.
+ *
+ * This procedure enables or disables kerning in a text layer.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_kerning (GimpLayer *layer,
+                             gboolean   kerning)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_BOOLEAN, kerning,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-kerning",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-kerning",
+                                            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_text_layer_set_kerning: (skip)
+ * @layer_ID: The text layer.
+ * @kerning: Enable/disable kerning in the text.
+ *
+ * Enable/disable kerning in a text layer.
+ *
+ * This procedure enables or disables kerning in a text layer.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_kerning (gint32   layer_ID,
+                              gboolean kerning)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, kerning,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-kerning",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-kerning",
+                                            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_text_layer_get_language:
+ * @layer: The text layer.
+ *
+ * Get the language used in the text layer.
+ *
+ * This procedure returns the language string which is set for the text
+ * in the text layer.
+ *
+ * Returns: (transfer full): The language used in the text layer.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.6
+ **/
+gchar *
+gimp_text_layer_get_language (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *language = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-language",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-language",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    language = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return language;
+}
+
+/**
+ * _gimp_text_layer_get_language: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Get the language used in the text layer.
+ *
+ * This procedure returns the language string which is set for the text
+ * in the text layer.
+ *
+ * Returns: The language used in the text layer.
+ *          The returned value must be freed with g_free().
+ *
+ * Since: 2.6
+ **/
+gchar *
+_gimp_text_layer_get_language (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gchar *language = NULL;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-language",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-language",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    language = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return language;
+}
+
+/**
+ * gimp_text_layer_set_language:
+ * @layer: The text layer.
+ * @language: The new language to use for the text layer.
+ *
+ * Set the language of the text layer.
+ *
+ * This procedure sets the language of the text in text layer. For some
+ * scripts the language has an influence of how the text is rendered.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_language (GimpLayer   *layer,
+                              const gchar *language)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_STRING, language,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-language",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-language",
+                                            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_text_layer_set_language: (skip)
+ * @layer_ID: The text layer.
+ * @language: The new language to use for the text layer.
+ *
+ * Set the language of the text layer.
+ *
+ * This procedure sets the language of the text in text layer. For some
+ * scripts the language has an influence of how the text is rendered.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_language (gint32       layer_ID,
+                               const gchar *language)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_STRING, language,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-language",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-language",
+                                            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_text_layer_get_base_direction:
+ * @layer: The text layer.
+ *
+ * Get the base direction used for rendering the text layer.
+ *
+ * This procedure returns the base direction used for rendering the
+ * text in the text layer
+ *
+ * Returns: The based direction used for the text layer.
+ *
+ * Since: 2.6
+ **/
+GimpTextDirection
+gimp_text_layer_get_base_direction (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextDirection direction = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-base-direction",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-base-direction",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    direction = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return direction;
+}
+
+/**
+ * _gimp_text_layer_get_base_direction: (skip)
+ * @layer_ID: The text layer.
+ *
+ * Get the base direction used for rendering the text layer.
+ *
+ * This procedure returns the base direction used for rendering the
+ * text in the text layer
+ *
+ * Returns: The based direction used for the text layer.
+ *
+ * Since: 2.6
+ **/
+GimpTextDirection
+_gimp_text_layer_get_base_direction (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextDirection direction = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-base-direction",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-base-direction",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    direction = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return direction;
+}
+
+/**
+ * gimp_text_layer_set_base_direction:
+ * @layer: The text layer.
+ * @direction: The base direction of the text.
+ *
+ * Set the base direction in the text layer.
+ *
+ * This procedure sets the base direction used in applying the Unicode
+ * bidirectional algorithm when rendering the text.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_base_direction (GimpLayer         *layer,
+                                    GimpTextDirection  direction)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_TEXT_DIRECTION, direction,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-base-direction",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-base-direction",
+                                            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_text_layer_set_base_direction: (skip)
+ * @layer_ID: The text layer.
+ * @direction: The base direction of the text.
+ *
+ * Set the base direction in the text layer.
+ *
+ * This procedure sets the base direction used in applying the Unicode
+ * bidirectional algorithm when rendering the text.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+_gimp_text_layer_set_base_direction (gint32            layer_ID,
+                                     GimpTextDirection direction)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gboolean success = TRUE;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_DIRECTION, direction,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-base-direction",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-base-direction",
+                                            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_text_layer_get_justification:
+ * @layer: The text layer.
+ *
+ * Get the text justification information of the text layer.
+ *
+ * This procedure returns the alignment of the lines in the text layer
+ * relative to each other.
+ *
+ * Returns: The justification used in the text layer.
+ *
+ * Since: 2.6
+ **/
+GimpTextJustification
+gimp_text_layer_get_justification (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextJustification justify = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-justification",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-justification",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    justify = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return justify;
 }
 
 /**
- * gimp_text_layer_set_hint_style:
+ * _gimp_text_layer_get_justification: (skip)
  * @layer_ID: The text layer.
- * @style: The new hint style.
  *
- * Control how font outlines are hinted in a text layer.
+ * Get the text justification information of the text layer.
  *
- * This procedure sets the hint style for font outlines in a text
- * layer. This controls whether to fit font outlines to the pixel grid,
- * and if so, whether to optimize for fidelity or contrast.
+ * This procedure returns the alignment of the lines in the text layer
+ * relative to each other.
+ *
+ * Returns: The justification used in the text layer.
+ *
+ * Since: 2.6
+ **/
+GimpTextJustification
+_gimp_text_layer_get_justification (gint32 layer_ID)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  GimpTextJustification justify = 0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-justification",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-justification",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    justify = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return justify;
+}
+
+/**
+ * gimp_text_layer_set_justification:
+ * @layer: The text layer.
+ * @justify: The justification for your text.
+ *
+ * Set the justification of the text in a text layer.
+ *
+ * This procedure sets the alignment of the lines in the text layer
+ * relative to each other.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.8
+ * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_hint_style (gint32            layer_ID,
-                                GimpTextHintStyle style)
+gimp_text_layer_set_justification (GimpLayer             *layer,
+                                   GimpTextJustification  justify)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -617,16 +1746,16 @@ gimp_text_layer_set_hint_style (gint32            layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_TEXT_HINT_STYLE, style,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_TEXT_JUSTIFICATION, justify,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-hint-style",
+                                                "gimp-text-layer-set-justification",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-hint-style",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-justification",
                                             args);
   gimp_value_array_unref (args);
 
@@ -638,63 +1767,65 @@ gimp_text_layer_set_hint_style (gint32            layer_ID,
 }
 
 /**
- * gimp_text_layer_get_kerning:
+ * _gimp_text_layer_set_justification: (skip)
  * @layer_ID: The text layer.
+ * @justify: The justification for your text.
  *
- * Check if kerning is used in the text layer.
+ * Set the justification of the text in a text layer.
  *
- * This procedure checks if kerning is enabled in the specified text
- * layer.
+ * This procedure sets the alignment of the lines in the text layer
+ * relative to each other.
  *
- * Returns: A flag which is true if kerning is used in the text layer.
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_get_kerning (gint32 layer_ID)
+_gimp_text_layer_set_justification (gint32                layer_ID,
+                                    GimpTextJustification justify)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean kerning = FALSE;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_JUSTIFICATION, justify,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-kerning",
+                                                "gimp-text-layer-set-justification",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-kerning",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-justification",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    kerning = 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 kerning;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_kerning:
- * @layer_ID: The text layer.
- * @kerning: Enable/disable kerning in the text.
+ * gimp_text_layer_get_color:
+ * @layer: The text layer.
+ * @color: (out caller-allocates): The color of the text.
  *
- * Enable/disable kerning in a text layer.
+ * Get the color of the text in a text layer.
  *
- * This procedure enables or disables kerning in a text layer.
+ * This procedure returns the color of the text in a text layer.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_kerning (gint32   layer_ID,
-                             gboolean kerning)
+gimp_text_layer_get_color (GimpLayer *layer,
+                           GimpRGB   *color)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -702,47 +1833,49 @@ gimp_text_layer_set_kerning (gint32   layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_BOOLEAN, kerning,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-kerning",
+                                                "gimp-text-layer-get-color",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-kerning",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-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), &*color);
+
   gimp_value_array_unref (return_vals);
 
   return success;
 }
 
 /**
- * gimp_text_layer_get_language:
+ * _gimp_text_layer_get_color: (skip)
  * @layer_ID: The text layer.
+ * @color: (out caller-allocates): The color of the text.
  *
- * Get the language used in the text layer.
+ * Get the color of the text in a text layer.
  *
- * This procedure returns the language string which is set for the text
- * in the text layer.
+ * This procedure returns the color of the text in a text layer.
  *
- * Returns: (transfer full): The language used in the text layer.
- *          The returned value must be freed with g_free().
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
-gchar *
-gimp_text_layer_get_language (gint32 layer_ID)
+gboolean
+_gimp_text_layer_get_color (gint32   layer_ID,
+                            GimpRGB *color)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gchar *language = NULL;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -750,38 +1883,82 @@ gimp_text_layer_get_language (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-language",
+                                                "gimp-text-layer-get-color",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-language",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-color",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    language = 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;
+
+  if (success)
+    gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
 
   gimp_value_array_unref (return_vals);
 
-  return language;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_language:
+ * gimp_text_layer_set_color:
+ * @layer: The text layer.
+ * @color: The color to use for the text.
+ *
+ * Set the color of the text in the text layer.
+ *
+ * This procedure sets the text color in the text layer 'layer'.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_text_layer_set_color (GimpLayer     *layer,
+                           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_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          GIMP_TYPE_RGB, color,
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-set-color",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-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_text_layer_set_color: (skip)
  * @layer_ID: The text layer.
- * @language: The new language to use for the text layer.
+ * @color: The color to use for the text.
  *
- * Set the language of the text layer.
+ * Set the color of the text in the text layer.
  *
- * This procedure sets the language of the text in text layer. For some
- * scripts the language has an influence of how the text is rendered.
+ * This procedure sets the text color in the text layer 'layer'.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_language (gint32       layer_ID,
-                              const gchar *language)
+_gimp_text_layer_set_color (gint32         layer_ID,
+                            const GimpRGB *color)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -790,15 +1967,15 @@ gimp_text_layer_set_language (gint32       layer_ID,
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_STRING, language,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-language",
+                                                "gimp-text-layer-set-color",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-language",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-color",
                                             args);
   gimp_value_array_unref (args);
 
@@ -810,25 +1987,67 @@ gimp_text_layer_set_language (gint32       layer_ID,
 }
 
 /**
- * gimp_text_layer_get_base_direction:
+ * gimp_text_layer_get_indent:
+ * @layer: The text layer.
+ *
+ * Get the line indentation of text layer.
+ *
+ * This procedure returns the indentation of the first line in a text
+ * layer.
+ *
+ * Returns: The indentation value of the first line.
+ *
+ * Since: 2.6
+ **/
+gdouble
+gimp_text_layer_get_indent (GimpLayer *layer)
+{
+  GimpPDB        *pdb = gimp_get_pdb ();
+  GimpValueArray *args;
+  GimpValueArray *return_vals;
+  gdouble indent = 0.0;
+
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_NONE);
+
+  if (pdb)
+    return_vals = gimp_pdb_run_procedure_array (pdb,
+                                                "gimp-text-layer-get-indent",
+                                                args);
+  else
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-indent",
+                                            args);
+  gimp_value_array_unref (args);
+
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    indent = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+  gimp_value_array_unref (return_vals);
+
+  return indent;
+}
+
+/**
+ * _gimp_text_layer_get_indent: (skip)
  * @layer_ID: The text layer.
  *
- * Get the base direction used for rendering the text layer.
+ * Get the line indentation of text layer.
  *
- * This procedure returns the base direction used for rendering the
- * text in the text layer
+ * This procedure returns the indentation of the first line in a text
+ * layer.
  *
- * Returns: The based direction used for the text layer.
+ * Returns: The indentation value of the first line.
  *
  * Since: 2.6
  **/
-GimpTextDirection
-gimp_text_layer_get_base_direction (gint32 layer_ID)
+gdouble
+_gimp_text_layer_get_indent (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpTextDirection direction = 0;
+  gdouble indent = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -836,38 +2055,38 @@ gimp_text_layer_get_base_direction (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-base-direction",
+                                                "gimp-text-layer-get-indent",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-base-direction",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-indent",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    direction = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+    indent = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return direction;
+  return indent;
 }
 
 /**
- * gimp_text_layer_set_base_direction:
- * @layer_ID: The text layer.
- * @direction: The base direction of the text.
+ * gimp_text_layer_set_indent:
+ * @layer: The text layer.
+ * @indent: The indentation for the first line.
  *
- * Set the base direction in the text layer.
+ * Set the indentation of the first line in a text layer.
  *
- * This procedure sets the base direction used in applying the Unicode
- * bidirectional algorithm when rendering the text.
+ * This procedure sets the indentation of the first line in the text
+ * layer.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_base_direction (gint32            layer_ID,
-                                    GimpTextDirection direction)
+gimp_text_layer_set_indent (GimpLayer *layer,
+                            gdouble    indent)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -875,16 +2094,16 @@ gimp_text_layer_set_base_direction (gint32            layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_TEXT_DIRECTION, direction,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, indent,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-base-direction",
+                                                "gimp-text-layer-set-indent",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-base-direction",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-indent",
                                             args);
   gimp_value_array_unref (args);
 
@@ -896,112 +2115,111 @@ gimp_text_layer_set_base_direction (gint32            layer_ID,
 }
 
 /**
- * gimp_text_layer_get_justification:
+ * _gimp_text_layer_set_indent: (skip)
  * @layer_ID: The text layer.
+ * @indent: The indentation for the first line.
  *
- * Get the text justification information of the text layer.
+ * Set the indentation of the first line in a text layer.
  *
- * This procedure returns the alignment of the lines in the text layer
- * relative to each other.
+ * This procedure sets the indentation of the first line in the text
+ * layer.
  *
- * Returns: The justification used in the text layer.
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
-GimpTextJustification
-gimp_text_layer_get_justification (gint32 layer_ID)
+gboolean
+_gimp_text_layer_set_indent (gint32  layer_ID,
+                             gdouble indent)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  GimpTextJustification justify = 0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, indent,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-justification",
+                                                "gimp-text-layer-set-indent",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-justification",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-indent",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    justify = g_value_get_enum (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 justify;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_justification:
- * @layer_ID: The text layer.
- * @justify: The justification for your text.
+ * gimp_text_layer_get_line_spacing:
+ * @layer: The text layer.
  *
- * Set the justification of the text in a text layer.
+ * Get the spacing between lines of text.
  *
- * This procedure sets the alignment of the lines in the text layer
- * relative to each other.
+ * This procedure returns the line-spacing between lines of text in a
+ * text layer.
  *
- * Returns: TRUE on success.
+ * Returns: The line-spacing value.
  *
  * Since: 2.6
  **/
-gboolean
-gimp_text_layer_set_justification (gint32                layer_ID,
-                                   GimpTextJustification justify)
+gdouble
+gimp_text_layer_get_line_spacing (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gdouble line_spacing = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_TEXT_JUSTIFICATION, justify,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-justification",
+                                                "gimp-text-layer-get-line-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-justification",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-line-spacing",
                                             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)
+    line_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return line_spacing;
 }
 
 /**
- * gimp_text_layer_get_color:
+ * _gimp_text_layer_get_line_spacing: (skip)
  * @layer_ID: The text layer.
- * @color: (out caller-allocates): The color of the text.
  *
- * Get the color of the text in a text layer.
+ * Get the spacing between lines of text.
  *
- * This procedure returns the color of the text in a text layer.
+ * This procedure returns the line-spacing between lines of text in a
+ * text layer.
  *
- * Returns: TRUE on success.
+ * Returns: The line-spacing value.
  *
  * Since: 2.6
  **/
-gboolean
-gimp_text_layer_get_color (gint32   layer_ID,
-                           GimpRGB *color)
+gdouble
+_gimp_text_layer_get_line_spacing (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gdouble line_spacing = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -1009,39 +2227,38 @@ gimp_text_layer_get_color (gint32   layer_ID,
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-color",
+                                                "gimp-text-layer-get-line-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-color",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-line-spacing",
                                             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), &*color);
+  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+    line_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return line_spacing;
 }
 
 /**
- * gimp_text_layer_set_color:
- * @layer_ID: The text layer.
- * @color: The color to use for the text.
+ * gimp_text_layer_set_line_spacing:
+ * @layer: The text layer.
+ * @line_spacing: The additional line spacing to use.
  *
- * Set the color of the text in the text layer.
+ * Adjust the line spacing in a text layer.
  *
- * This procedure sets the text color in the text layer 'layer'.
+ * This procedure sets the additional spacing used between lines a text
+ * layer.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_color (gint32         layer_ID,
-                           const GimpRGB *color)
+gimp_text_layer_set_line_spacing (GimpLayer *layer,
+                                  gdouble    line_spacing)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1049,16 +2266,16 @@ gimp_text_layer_set_color (gint32         layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          GIMP_TYPE_RGB, color,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, line_spacing,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-color",
+                                                "gimp-text-layer-set-line-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-color",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-line-spacing",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1070,111 +2287,111 @@ gimp_text_layer_set_color (gint32         layer_ID,
 }
 
 /**
- * gimp_text_layer_get_indent:
+ * _gimp_text_layer_set_line_spacing: (skip)
  * @layer_ID: The text layer.
+ * @line_spacing: The additional line spacing to use.
  *
- * Get the line indentation of text layer.
+ * Adjust the line spacing in a text layer.
  *
- * This procedure returns the indentation of the first line in a text
+ * This procedure sets the additional spacing used between lines a text
  * layer.
  *
- * Returns: The indentation value of the first line.
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
-gdouble
-gimp_text_layer_get_indent (gint32 layer_ID)
+gboolean
+_gimp_text_layer_set_line_spacing (gint32  layer_ID,
+                                   gdouble line_spacing)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gdouble indent = 0.0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, line_spacing,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-indent",
+                                                "gimp-text-layer-set-line-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-indent",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-line-spacing",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    indent = g_value_get_double (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 indent;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_indent:
- * @layer_ID: The text layer.
- * @indent: The indentation for the first line.
+ * gimp_text_layer_get_letter_spacing:
+ * @layer: The text layer.
  *
- * Set the indentation of the first line in a text layer.
+ * Get the letter spacing used in a text layer.
  *
- * This procedure sets the indentation of the first line in the text
- * layer.
+ * This procedure returns the additional spacing between the single
+ * glyphs in a text layer.
  *
- * Returns: TRUE on success.
+ * Returns: The letter-spacing value.
  *
  * Since: 2.6
  **/
-gboolean
-gimp_text_layer_set_indent (gint32  layer_ID,
-                            gdouble indent)
+gdouble
+gimp_text_layer_get_letter_spacing (GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gboolean success = TRUE;
+  gdouble letter_spacing = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_DOUBLE, indent,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-indent",
+                                                "gimp-text-layer-get-letter-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-indent",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-letter-spacing",
                                             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)
+    letter_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return success;
+  return letter_spacing;
 }
 
 /**
- * gimp_text_layer_get_line_spacing:
+ * _gimp_text_layer_get_letter_spacing: (skip)
  * @layer_ID: The text layer.
  *
- * Get the spacing between lines of text.
+ * Get the letter spacing used in a text layer.
  *
- * This procedure returns the line-spacing between lines of text in a
- * text layer.
+ * This procedure returns the additional spacing between the single
+ * glyphs in a text layer.
  *
- * Returns: The line-spacing value.
+ * Returns: The letter-spacing value.
  *
  * Since: 2.6
  **/
 gdouble
-gimp_text_layer_get_line_spacing (gint32 layer_ID)
+_gimp_text_layer_get_letter_spacing (gint32 layer_ID)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gdouble line_spacing = 0.0;
+  gdouble letter_spacing = 0.0;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
@@ -1182,38 +2399,38 @@ gimp_text_layer_get_line_spacing (gint32 layer_ID)
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-line-spacing",
+                                                "gimp-text-layer-get-letter-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-line-spacing",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-letter-spacing",
                                             args);
   gimp_value_array_unref (args);
 
   if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    line_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
+    letter_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
 
   gimp_value_array_unref (return_vals);
 
-  return line_spacing;
+  return letter_spacing;
 }
 
 /**
- * gimp_text_layer_set_line_spacing:
- * @layer_ID: The text layer.
- * @line_spacing: The additional line spacing to use.
+ * gimp_text_layer_set_letter_spacing:
+ * @layer: The text layer.
+ * @letter_spacing: The additional letter spacing to use.
  *
- * Adjust the line spacing in a text layer.
+ * Adjust the letter spacing in a text layer.
  *
- * This procedure sets the additional spacing used between lines a text
- * layer.
+ * This procedure sets the additional spacing between the single glyphs
+ * in a text layer.
  *
  * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
 gboolean
-gimp_text_layer_set_line_spacing (gint32  layer_ID,
-                                  gdouble line_spacing)
+gimp_text_layer_set_letter_spacing (GimpLayer *layer,
+                                    gdouble    letter_spacing)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1221,16 +2438,16 @@ gimp_text_layer_set_line_spacing (gint32  layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_DOUBLE, line_spacing,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, letter_spacing,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-line-spacing",
+                                                "gimp-text-layer-set-letter-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-line-spacing",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-letter-spacing",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1242,64 +2459,69 @@ gimp_text_layer_set_line_spacing (gint32  layer_ID,
 }
 
 /**
- * gimp_text_layer_get_letter_spacing:
+ * _gimp_text_layer_set_letter_spacing: (skip)
  * @layer_ID: The text layer.
+ * @letter_spacing: The additional letter spacing to use.
  *
- * Get the letter spacing used in a text layer.
+ * Adjust the letter spacing in a text layer.
  *
- * This procedure returns the additional spacing between the single
- * glyphs in a text layer.
+ * This procedure sets the additional spacing between the single glyphs
+ * in a text layer.
  *
- * Returns: The letter-spacing value.
+ * Returns: TRUE on success.
  *
  * Since: 2.6
  **/
-gdouble
-gimp_text_layer_get_letter_spacing (gint32 layer_ID)
+gboolean
+_gimp_text_layer_set_letter_spacing (gint32  layer_ID,
+                                     gdouble letter_spacing)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gdouble letter_spacing = 0.0;
+  gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, letter_spacing,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-get-letter-spacing",
+                                                "gimp-text-layer-set-letter-spacing",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-get-letter-spacing",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-letter-spacing",
                                             args);
   gimp_value_array_unref (args);
 
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    letter_spacing = g_value_get_double (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 letter_spacing;
+  return success;
 }
 
 /**
- * gimp_text_layer_set_letter_spacing:
- * @layer_ID: The text layer.
- * @letter_spacing: The additional letter spacing to use.
+ * gimp_text_layer_resize:
+ * @layer: The text layer.
+ * @width: The new box width in pixels.
+ * @height: The new box height in pixels.
  *
- * Adjust the letter spacing in a text layer.
+ * Resize the box of a text layer.
  *
- * This procedure sets the additional spacing between the single glyphs
- * in a text layer.
+ * This procedure changes the width and height of a text layer while
+ * keeping it as a text layer and not converting it to a bitmap like
+ * gimp_layer_resize() would do.
  *
  * Returns: TRUE on success.
  *
- * Since: 2.6
+ * Since: 2.8
  **/
 gboolean
-gimp_text_layer_set_letter_spacing (gint32  layer_ID,
-                                    gdouble letter_spacing)
+gimp_text_layer_resize (GimpLayer *layer,
+                        gdouble    width,
+                        gdouble    height)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -1307,16 +2529,17 @@ gimp_text_layer_set_letter_spacing (gint32  layer_ID,
   gboolean success = TRUE;
 
   args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          G_TYPE_DOUBLE, letter_spacing,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
                                           G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-text-layer-set-letter-spacing",
+                                                "gimp-text-layer-resize",
                                                 args);
   else
-    return_vals = gimp_run_procedure_array ("gimp-text-layer-set-letter-spacing",
+    return_vals = gimp_run_procedure_array ("gimp-text-layer-resize",
                                             args);
   gimp_value_array_unref (args);
 
@@ -1328,7 +2551,7 @@ gimp_text_layer_set_letter_spacing (gint32  layer_ID,
 }
 
 /**
- * gimp_text_layer_resize:
+ * _gimp_text_layer_resize: (skip)
  * @layer_ID: The text layer.
  * @width: The new box width in pixels.
  * @height: The new box height in pixels.
@@ -1344,9 +2567,9 @@ gimp_text_layer_set_letter_spacing (gint32  layer_ID,
  * Since: 2.8
  **/
 gboolean
-gimp_text_layer_resize (gint32  layer_ID,
-                        gdouble width,
-                        gdouble height)
+_gimp_text_layer_resize (gint32  layer_ID,
+                         gdouble width,
+                         gdouble height)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
diff --git a/libgimp/gimptextlayer_pdb.h b/libgimp/gimptextlayer_pdb.h
index d409cfca1c..eb0c3f56f4 100644
--- a/libgimp/gimptextlayer_pdb.h
+++ b/libgimp/gimptextlayer_pdb.h
@@ -32,64 +32,93 @@ G_BEGIN_DECLS
 /* For information look into the C source or the html documentation */
 
 
-gchar*                gimp_text_layer_get_text           (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_text           (gint32                 layer_ID,
+
+
+#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
+
+GimpLayer*            gimp_text_layer_new                (GimpImage             *image,
+                                                          const gchar           *text,
+                                                          const gchar           *fontname,
+                                                          gdouble                size,
+                                                          GimpUnit               unit);
+gchar*                gimp_text_layer_get_text           (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_text           (GimpLayer             *layer,
                                                           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,
+gchar*                gimp_text_layer_get_markup         (GimpLayer             *layer);
+gchar*                gimp_text_layer_get_font           (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_font           (GimpLayer             *layer,
                                                           const gchar           *font);
-gdouble               gimp_text_layer_get_font_size      (gint32                 layer_ID,
+gdouble               gimp_text_layer_get_font_size      (GimpLayer             *layer,
                                                           GimpUnit              *unit);
-gboolean              gimp_text_layer_set_font_size      (gint32                 layer_ID,
+gboolean              gimp_text_layer_set_font_size      (GimpLayer             *layer,
                                                           gdouble                font_size,
                                                           GimpUnit               unit);
-gboolean              gimp_text_layer_get_antialias      (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_antialias      (gint32                 layer_ID,
+gboolean              gimp_text_layer_get_antialias      (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_antialias      (GimpLayer             *layer,
                                                           gboolean               antialias);
-GimpTextHintStyle     gimp_text_layer_get_hint_style     (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_hint_style     (gint32                 layer_ID,
+GimpTextHintStyle     gimp_text_layer_get_hint_style     (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_hint_style     (GimpLayer             *layer,
                                                           GimpTextHintStyle      style);
-gboolean              gimp_text_layer_get_kerning        (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_kerning        (gint32                 layer_ID,
+gboolean              gimp_text_layer_get_kerning        (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_kerning        (GimpLayer             *layer,
                                                           gboolean               kerning);
-gchar*                gimp_text_layer_get_language       (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_language       (gint32                 layer_ID,
+gchar*                gimp_text_layer_get_language       (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_language       (GimpLayer             *layer,
                                                           const gchar           *language);
-GimpTextDirection     gimp_text_layer_get_base_direction (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_base_direction (gint32                 layer_ID,
+GimpTextDirection     gimp_text_layer_get_base_direction (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_base_direction (GimpLayer             *layer,
                                                           GimpTextDirection      direction);
-GimpTextJustification gimp_text_layer_get_justification  (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_justification  (gint32                 layer_ID,
+GimpTextJustification gimp_text_layer_get_justification  (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_justification  (GimpLayer             *layer,
                                                           GimpTextJustification  justify);
-gboolean              gimp_text_layer_get_color          (gint32                 layer_ID,
+gboolean              gimp_text_layer_get_color          (GimpLayer             *layer,
                                                           GimpRGB               *color);
-gboolean              gimp_text_layer_set_color          (gint32                 layer_ID,
+gboolean              gimp_text_layer_set_color          (GimpLayer             *layer,
                                                           const GimpRGB         *color);
-gdouble               gimp_text_layer_get_indent         (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_indent         (gint32                 layer_ID,
+gdouble               gimp_text_layer_get_indent         (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_indent         (GimpLayer             *layer,
                                                           gdouble                indent);
-gdouble               gimp_text_layer_get_line_spacing   (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_line_spacing   (gint32                 layer_ID,
+gdouble               gimp_text_layer_get_line_spacing   (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_line_spacing   (GimpLayer             *layer,
                                                           gdouble                line_spacing);
-gdouble               gimp_text_layer_get_letter_spacing (gint32                 layer_ID);
-gboolean              gimp_text_layer_set_letter_spacing (gint32                 layer_ID,
+gdouble               gimp_text_layer_get_letter_spacing (GimpLayer             *layer);
+gboolean              gimp_text_layer_set_letter_spacing (GimpLayer             *layer,
                                                           gdouble                letter_spacing);
-gboolean              gimp_text_layer_resize             (gint32                 layer_ID,
+gboolean              gimp_text_layer_resize             (GimpLayer             *layer,
                                                           gdouble                width,
                                                           gdouble                height);
 
-#ifndef GIMP_DEPRECATED_REPLACE_NEW_API
-
-gint32 gimp_text_layer_new (GimpImage   *image,
-                            const gchar *text,
-                            const gchar *fontname,
-                            gdouble      size,
-                            GimpUnit     unit);
-
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
 #define gimp_text_layer_new _gimp_text_layer_new
+#define gimp_text_layer_get_text _gimp_text_layer_get_text
+#define gimp_text_layer_set_text _gimp_text_layer_set_text
+#define gimp_text_layer_get_markup _gimp_text_layer_get_markup
+#define gimp_text_layer_get_font _gimp_text_layer_get_font
+#define gimp_text_layer_set_font _gimp_text_layer_set_font
+#define gimp_text_layer_get_font_size _gimp_text_layer_get_font_size
+#define gimp_text_layer_set_font_size _gimp_text_layer_set_font_size
+#define gimp_text_layer_get_antialias _gimp_text_layer_get_antialias
+#define gimp_text_layer_set_antialias _gimp_text_layer_set_antialias
+#define gimp_text_layer_get_hint_style _gimp_text_layer_get_hint_style
+#define gimp_text_layer_set_hint_style _gimp_text_layer_set_hint_style
+#define gimp_text_layer_get_kerning _gimp_text_layer_get_kerning
+#define gimp_text_layer_set_kerning _gimp_text_layer_set_kerning
+#define gimp_text_layer_get_language _gimp_text_layer_get_language
+#define gimp_text_layer_set_language _gimp_text_layer_set_language
+#define gimp_text_layer_get_base_direction _gimp_text_layer_get_base_direction
+#define gimp_text_layer_set_base_direction _gimp_text_layer_set_base_direction
+#define gimp_text_layer_get_justification _gimp_text_layer_get_justification
+#define gimp_text_layer_set_justification _gimp_text_layer_set_justification
+#define gimp_text_layer_get_color _gimp_text_layer_get_color
+#define gimp_text_layer_set_color _gimp_text_layer_set_color
+#define gimp_text_layer_get_indent _gimp_text_layer_get_indent
+#define gimp_text_layer_set_indent _gimp_text_layer_set_indent
+#define gimp_text_layer_get_line_spacing _gimp_text_layer_get_line_spacing
+#define gimp_text_layer_set_line_spacing _gimp_text_layer_set_line_spacing
+#define gimp_text_layer_get_letter_spacing _gimp_text_layer_get_letter_spacing
+#define gimp_text_layer_set_letter_spacing _gimp_text_layer_set_letter_spacing
+#define gimp_text_layer_resize _gimp_text_layer_resize
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -98,11 +127,57 @@ gint32 gimp_text_layer_new (GimpImage   *image,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-gint32 _gimp_text_layer_new (gint32       image_ID,
-                             const gchar *text,
-                             const gchar *fontname,
-                             gdouble      size,
-                             GimpUnit     unit);
+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 8777c5937c..34fd711e6c 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -37,7 +37,7 @@
 /**
  * gimp_text_fontname:
  * @image: The image.
- * @drawable_ID: The affected drawable: (-1 for a new text layer).
+ * @drawable: 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).
@@ -64,11 +64,11 @@
  * 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.
+ * Returns: (transfer full): The new text layer or -1 if no layer was created.
  **/
-gint32
+GimpLayer *
 gimp_text_fontname (GimpImage    *image,
-                    gint32        drawable_ID,
+                    GimpDrawable *drawable,
                     gdouble       x,
                     gdouble       y,
                     const gchar  *text,
@@ -81,11 +81,11 @@ gimp_text_fontname (GimpImage    *image,
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
   GimpValueArray *return_vals;
-  gint32 text_layer_ID = -1;
+  GimpLayer *text_layer = NULL;
 
   args = gimp_value_array_new_from_types (NULL,
                                           GIMP_TYPE_IMAGE_ID, gimp_image_get_id (image),
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, gimp_item_get_id (GIMP_ITEM (drawable)),
                                           G_TYPE_DOUBLE, x,
                                           G_TYPE_DOUBLE, y,
                                           G_TYPE_STRING, text,
@@ -106,11 +106,11 @@ gimp_text_fontname (GimpImage    *image,
   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));
+    text_layer = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id (gimp_value_array_index 
(return_vals, 1))));
 
   gimp_value_array_unref (return_vals);
 
-  return text_layer_ID;
+  return text_layer;
 }
 
 /**
diff --git a/libgimp/gimptexttool_pdb.h b/libgimp/gimptexttool_pdb.h
index 3d9b1c03b2..09d1fe5093 100644
--- a/libgimp/gimptexttool_pdb.h
+++ b/libgimp/gimptexttool_pdb.h
@@ -43,16 +43,16 @@ gboolean gimp_text_get_extents_fontname (const gchar  *text,
 
 #ifndef GIMP_DEPRECATED_REPLACE_NEW_API
 
-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);
+GimpLayer* gimp_text_fontname (GimpImage    *image,
+                               GimpDrawable *drawable,
+                               gdouble       x,
+                               gdouble       y,
+                               const gchar  *text,
+                               gint          border,
+                               gboolean      antialias,
+                               gdouble       size,
+                               GimpSizeType  size_type,
+                               const gchar  *fontname);
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
diff --git a/libgimp/gimptypes.h b/libgimp/gimptypes.h
index 515ff5caea..49d827b310 100644
--- a/libgimp/gimptypes.h
+++ b/libgimp/gimptypes.h
@@ -38,6 +38,9 @@ typedef union  _GimpParamData   GimpParamData;
 typedef struct _GimpParam       GimpParam;
 
 typedef struct _GimpImage       GimpImage;
+typedef struct _GimpItem        GimpItem;
+typedef struct _GimpDrawable    GimpDrawable;
+typedef struct _GimpLayer       GimpLayer;
 
 
 /* FIXME move somewhere else */
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index 3f3a6c7499..4589f516b6 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -127,7 +127,7 @@ _gimp_vectors_new (gint32       image_ID,
 /**
  * gimp_vectors_new_from_text_layer:
  * @image: The image.
- * @layer_ID: The text layer.
+ * @layer: The text layer.
  *
  * Creates a new vectors object from a text layer.
  *
@@ -140,7 +140,7 @@ _gimp_vectors_new (gint32       image_ID,
  **/
 gint32
 gimp_vectors_new_from_text_layer (GimpImage *image,
-                                  gint32     layer_ID)
+                                  GimpLayer *layer)
 {
   GimpPDB        *pdb = gimp_get_pdb ();
   GimpValueArray *args;
@@ -149,7 +149,7 @@ gimp_vectors_new_from_text_layer (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,
+                                          GIMP_TYPE_LAYER_ID, gimp_item_get_id (GIMP_ITEM (layer)),
                                           G_TYPE_NONE);
 
   if (pdb)
diff --git a/libgimp/gimpvectors_pdb.h b/libgimp/gimpvectors_pdb.h
index 62126fc6cf..e12c21c795 100644
--- a/libgimp/gimpvectors_pdb.h
+++ b/libgimp/gimpvectors_pdb.h
@@ -121,7 +121,7 @@ gint                  gimp_vectors_bezier_stroke_new_ellipse (gint32
 gint32   gimp_vectors_new                 (GimpImage    *image,
                                            const gchar  *name);
 gint32   gimp_vectors_new_from_text_layer (GimpImage    *image,
-                                           gint32        layer_ID);
+                                           GimpLayer    *layer);
 gboolean gimp_vectors_import_from_file    (GimpImage    *image,
                                            const gchar  *filename,
                                            gboolean      merge,
diff --git a/pdb/lib.pl b/pdb/lib.pl
index 74efcbdb3e..9ff9460859 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -45,8 +45,17 @@ sub desc_wrap {
     return $wrapped;
 }
 
+sub is_id_arg {
+    my ($arg) = @_;
+
+    return ($arg->{name} eq 'IMAGE'    ||
+            $arg->{name} eq 'ITEM'     ||
+            $arg->{name} eq 'DRAWABLE' ||
+            $arg->{name} eq 'LAYER');
+}
+
 sub generate_fun {
-    my ($proc, $out, $api_deprecated, $has_image_arg) = @_;
+    my ($proc, $out, $api_deprecated, $has_id_arg) = @_;
     my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs});
     my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs});
 
@@ -58,7 +67,7 @@ sub generate_fun {
        my $argtype = $arg_types{$type};
        my $rettype = '';
 
-        if ($api_deprecated && $argtype->{name} eq 'IMAGE') {
+        if ($api_deprecated && is_id_arg($argtype)) {
             return 'gint32 ';
         }
 
@@ -211,7 +220,7 @@ sub generate_fun {
         my $desc = exists $_->{desc} ? $_->{desc} : "";
         my $var_len;
         my $value;
-        my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE'));
+        my $is_id = ($arg->{id} || ($api_deprecated && is_id_arg($arg)));
 
         $var .= '_ID' if $is_id;
 
@@ -309,7 +318,7 @@ sub generate_fun {
             my ($type) = &arg_parse($_->{type});
             my $arg = $arg_types{$type};
             my $var;
-            my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE'));
+            my $is_id = ($arg->{id} || ($api_deprecated && is_id_arg($arg)));
 
             $return_marshal = "" unless $once++;
 
@@ -390,7 +399,7 @@ CODE
             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 $is_id = ($arg->{id} || ($api_deprecated && is_id_arg($arg)));
             my $var;
 
             # The return value variable
@@ -521,7 +530,7 @@ CODE
         push @{$out->{protos_deprecated}}, $proto;
         push @{$out->{defines_deprecated}}, $define_dep;
     }
-    elsif (! $has_image_arg){
+    elsif (! $has_id_arg){
         push @{$out->{protos_no_alt}}, $proto;
     }
     else {
@@ -720,28 +729,28 @@ sub generate {
        my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs});
 
         # Check if any of the argument or returned value is an image.
-        $has_image_arg = 0;
+        $has_id_arg = 0;
        foreach (@outargs) {
            my ($type, @typeinfo) = &arg_parse($_->{type});
            my $arg = $arg_types{$type};
-           if ($arg->{name} eq 'IMAGE') {
-                $has_image_arg = 1;
+            if (is_id_arg($arg)) {
+                $has_id_arg = 1;
                 last;
             }
        }
-        unless ($has_image_arg) {
+        unless ($has_id_arg) {
             foreach (@inargs) {
                 my ($type, @typeinfo) = &arg_parse($_->{type});
                 my $arg = $arg_types{$type};
-                if ($arg->{name} eq 'IMAGE') {
-                    $has_image_arg = 1;
+                if (is_id_arg($arg)) {
+                    $has_id_arg = 1;
                     last;
                 }
             }
         }
-        $out->{code} .= generate_fun($proc, $out, 0, $has_image_arg);
-        if ($has_image_arg) {
-            $out->{code} .= generate_fun($proc, $out, 1, $has_image_arg);
+        $out->{code} .= generate_fun($proc, $out, 0, $has_id_arg);
+        if ($has_id_arg) {
+            $out->{code} .= generate_fun($proc, $out, 1, $has_id_arg);
         }
     }
 
diff --git a/pdb/pdb.pl b/pdb/pdb.pl
index 409ddee7c7..0775c55e48 100644
--- a/pdb/pdb.pl
+++ b/pdb/pdb.pl
@@ -177,24 +177,28 @@ package Gimp::CodeGen::pdb;
                     gtype           => 'GIMP_TYPE_ITEM_ID',
                     type            => 'GimpItem *',
                     const_type      => 'GimpItem *',
-                    id              => 1,
                     init_value      => 'NULL',
+                    out_annotate    => '(transfer full)',
                     get_value_func  => '$var = gimp_value_get_item ($value, gimp)',
-                    dup_value_func  => '$var = gimp_value_get_item_id ($value)',
+                    dup_value_func  => '$var = gimp_item_new_by_id (gimp_value_get_item_id ($value))',
+                    dup_value_func_d=> '$var = gimp_value_get_item_id ($value)',
                     set_value_func  => 'gimp_value_set_item_id ($value, $var)',
                     take_value_func => 'gimp_value_set_item ($value, $var)',
+                    convert_func    => 'gimp_item_get_id (GIMP_ITEM ($var))',
                     headers         => [ qw("core/gimpitem.h") ] },
 
     layer       => { name            => 'LAYER',
                     gtype           => 'GIMP_TYPE_LAYER_ID',
                     type            => 'GimpLayer *',
                     const_type      => 'GimpLayer *',
-                    id              => 1,
                     init_value      => 'NULL',
+                    out_annotate    => '(transfer full)',
                     get_value_func  => '$var = gimp_value_get_layer ($value, gimp)',
-                    dup_value_func  => '$var = gimp_value_get_layer_id ($value)',
+                    dup_value_func  => '$var = GIMP_LAYER (gimp_item_new_by_id (gimp_value_get_layer_id 
($value)))',
+                    dup_value_func_d=> '$var = gimp_value_get_layer_id ($value)',
                     set_value_func  => 'gimp_value_set_layer_id ($value, $var)',
                     take_value_func => 'gimp_value_set_layer ($value, $var)',
+                    convert_func    => 'gimp_item_get_id (GIMP_ITEM ($var))',
                     headers         => [ qw("core/gimplayer.h") ] },
 
     channel     => { name            => 'CHANNEL',
@@ -213,12 +217,14 @@ package Gimp::CodeGen::pdb;
                     gtype           => 'GIMP_TYPE_DRAWABLE_ID',
                     type            => 'GimpDrawable *',
                     const_type      => 'GimpDrawable *',
-                    id              => 1,
                     init_value      => 'NULL',
+                    out_annotate    => '(transfer full)',
                     get_value_func  => '$var = gimp_value_get_drawable ($value, gimp)',
-                    dup_value_func  => '$var = gimp_value_get_drawable_id ($value)',
+                    dup_value_func  => '$var = GIMP_DRAWABLE (gimp_item_new_by_id 
(gimp_value_get_drawable_id ($value)))',
+                    dup_value_func_d=> '$var = gimp_value_get_drawable_id ($value)',
                     set_value_func  => 'gimp_value_set_drawable_id ($value, $var)',
                     take_value_func => 'gimp_value_set_drawable ($value, $var)',
+                    convert_func    => 'gimp_item_get_id (GIMP_ITEM ($var))',
                     headers         => [ qw("core/gimpdrawable.h") ] },
 
     selection   => { name            => 'SELECTION',


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