[gimp/wip/Jehan/classy-GIMP: 29/60] libgimp, pdb: no need to create deprecated versions for private API.



commit 74f660db5b33f39fab0e10b45805e791a498dfdd
Author: Jehan <jehan girinstud io>
Date:   Wed Aug 14 09:37:25 2019 +0200

    libgimp, pdb: no need to create deprecated versions for private API.

 libgimp/gimpchannel_pdb.c           |  60 -------
 libgimp/gimpchannel_pdb.h           |   7 -
 libgimp/gimpdrawable_pdb.c          | 247 -----------------------------
 libgimp/gimpdrawable_pdb.h          | 124 ++++++---------
 libgimp/gimpimage_pdb.c             | 253 ------------------------------
 libgimp/gimpimage_pdb.h             | 305 +++++++++++++++++-------------------
 libgimp/gimpimagecolorprofile_pdb.c | 210 -------------------------
 libgimp/gimpimagecolorprofile_pdb.h |  16 --
 libgimp/gimplayer_pdb.c             | 109 -------------
 libgimp/gimplayer_pdb.h             |  11 --
 libgimp/gimpprogress_pdb.c          |  42 -----
 libgimp/gimpprogress_pdb.h          |   4 +-
 libgimp/gimpselection_pdb.c         |  50 ------
 libgimp/gimpselection_pdb.h         |   4 -
 pdb/lib.pl                          |   4 +
 15 files changed, 196 insertions(+), 1250 deletions(-)
---
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index ca4302d3a4..9a9ef83146 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -94,66 +94,6 @@ _gimp_channel_new (GimpImage     *image,
   return channel;
 }
 
-/**
- * __gimp_channel_new: (skip)
- * @image_ID: The image to which to add the channel.
- * @width: The channel width.
- * @height: The channel height.
- * @name: The channel name.
- * @opacity: The channel opacity.
- * @color: The channel compositing color.
- *
- * Create a new channel.
- *
- * This procedure creates a new channel with the specified width,
- * height, name, opacity and color.
- * The new channel still needs to be added to the image, as this is not
- * automatic. Add the new channel with gimp_image_insert_channel().
- * Other attributes, such as channel visibility, should be set with
- * explicit procedure calls.
- * The channel's contents are undefined initially.
- *
- * Returns: The newly created channel.
- **/
-gint32
-__gimp_channel_new (gint32         image_ID,
-                    gint           width,
-                    gint           height,
-                    const gchar   *name,
-                    gdouble        opacity,
-                    const GimpRGB *color)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gint32 channel_ID = -1;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, width,
-                                          G_TYPE_INT, height,
-                                          G_TYPE_STRING, name,
-                                          G_TYPE_DOUBLE, opacity,
-                                          GIMP_TYPE_RGB, color,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-channel-new",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-channel-new",
-                                            args);
-  gimp_value_array_unref (args);
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return channel_ID;
-}
-
 /**
  * gimp_channel_new_from_component:
  * @image: The image to which to add the channel.
diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h
index 2136e26909..49a70ca5dc 100644
--- a/libgimp/gimpchannel_pdb.h
+++ b/libgimp/gimpchannel_pdb.h
@@ -64,7 +64,6 @@ gboolean                     gimp_channel_set_color          (GimpChannel     *c
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
-#define _gimp_channel_new __gimp_channel_new
 #define gimp_channel_new_from_component _gimp_channel_new_from_component
 #define gimp_channel_copy _gimp_channel_copy
 #define gimp_channel_combine_masks _gimp_channel_combine_masks
@@ -82,12 +81,6 @@ gboolean                     gimp_channel_set_color          (GimpChannel     *c
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-gint32   __gimp_channel_new               (gint32           image_ID,
-                                           gint             width,
-                                           gint             height,
-                                           const gchar     *name,
-                                           gdouble          opacity,
-                                           const GimpRGB   *color);
 gint32   _gimp_channel_new_from_component (gint32           image_ID,
                                            GimpChannelType  component,
                                            const gchar     *name);
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index 8078e7cbc6..c23cd3c43e 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -79,51 +79,6 @@ _gimp_drawable_get_format (GimpDrawable *drawable)
   return format;
 }
 
-/**
- * __gimp_drawable_get_format: (skip)
- * @drawable_ID: The drawable.
- *
- * Returns the drawable's Babl format
- *
- * 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: The drawable's Babl format.
- *          The returned value must be freed with g_free().
- *
- * Since: 2.10
- **/
-gchar *
-__gimp_drawable_get_format (gint32 drawable_ID)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gchar *format = NULL;
-
-  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-get-format",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-drawable-get-format",
-                                            args);
-  gimp_value_array_unref (args);
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return format;
-}
-
 /**
  * _gimp_drawable_get_thumbnail_format:
  * @drawable: The drawable.
@@ -168,50 +123,6 @@ _gimp_drawable_get_thumbnail_format (GimpDrawable *drawable)
   return format;
 }
 
-/**
- * __gimp_drawable_get_thumbnail_format: (skip)
- * @drawable_ID: The drawable.
- *
- * Returns the drawable's thumbnail 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().
- *
- * Returns: The drawable's thumbnail Babl format.
- *          The returned value must be freed with g_free().
- *
- * Since: 2.10.14
- **/
-gchar *
-__gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gchar *format = NULL;
-
-  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-get-thumbnail-format",
-                                                args);
-  else
-    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)
-    format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return format;
-}
-
 /**
  * gimp_drawable_type:
  * @drawable: The drawable.
@@ -2073,78 +1984,6 @@ _gimp_drawable_thumbnail (GimpDrawable  *drawable,
   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;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          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_sub_thumbnail:
  * @drawable: The drawable.
@@ -2231,92 +2070,6 @@ _gimp_drawable_sub_thumbnail (GimpDrawable  *drawable,
   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;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          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_foreground_extract:
  * @drawable: The drawable.
diff --git a/libgimp/gimpdrawable_pdb.h b/libgimp/gimpdrawable_pdb.h
index 56e54f4f10..b46f0d7783 100644
--- a/libgimp/gimpdrawable_pdb.h
+++ b/libgimp/gimpdrawable_pdb.h
@@ -110,8 +110,6 @@ gboolean                 gimp_drawable_foreground_extract    (GimpDrawable
 
 #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
@@ -131,8 +129,6 @@ gboolean                 gimp_drawable_foreground_extract    (GimpDrawable
 #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
 
 
@@ -142,77 +138,55 @@ gboolean                 gimp_drawable_foreground_extract    (GimpDrawable
  * 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);
+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_foreground_extract (gint32                     drawable_ID,
+                                                 GimpForegroundExtractMode  mode,
+                                                 gint32                     mask_ID);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 9da6806816..3f9eb8c5db 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -3833,57 +3833,6 @@ _gimp_image_get_colormap (GimpImage *image,
   return colormap;
 }
 
-/**
- * __gimp_image_get_colormap: (skip)
- * @image_ID: The image.
- * @num_bytes: (out): Number of bytes in the colormap array.
- *
- * Returns the image's colormap
- *
- * This procedure returns an actual pointer to the image's colormap, as
- * well as the number of bytes contained in the colormap. The actual
- * number of colors in the transmitted colormap will be 'num-bytes' /
- * 3. If the image is not in Indexed color mode, no colormap is
- * returned.
- *
- * Returns: (array length=num_bytes): The image's colormap.
- *          The returned value must be freed with g_free().
- **/
-guint8 *
-__gimp_image_get_colormap (gint32  image_ID,
-                           gint   *num_bytes)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  guint8 *colormap = NULL;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-colormap",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-colormap",
-                                            args);
-  gimp_value_array_unref (args);
-
-  *num_bytes = 0;
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      colormap = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
-    }
-
-  gimp_value_array_unref (return_vals);
-
-  return colormap;
-}
-
 /**
  * _gimp_image_set_colormap:
  * @image: The image.
@@ -3933,55 +3882,6 @@ _gimp_image_set_colormap (GimpImage    *image,
   return success;
 }
 
-/**
- * __gimp_image_set_colormap: (skip)
- * @image_ID: The image.
- * @num_bytes: Number of bytes in the colormap array.
- * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
- *
- * Sets the entries in the image's colormap.
- *
- * This procedure sets the entries in the specified image's colormap.
- * The number of entries is specified by the 'num-bytes' parameter and
- * corresponds to the number of INT8 triples that must be contained in
- * the 'colormap' array. The actual number of colors in the transmitted
- * colormap is 'num-bytes' / 3.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-__gimp_image_set_colormap (gint32        image_ID,
-                           gint          num_bytes,
-                           const guint8 *colormap)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, num_bytes,
-                                          GIMP_TYPE_UINT8_ARRAY, NULL,
-                                          G_TYPE_NONE);
-  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-colormap",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-colormap",
-                                            args);
-  gimp_value_array_unref (args);
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  gimp_value_array_unref (return_vals);
-
-  return success;
-}
-
 /**
  * _gimp_image_get_metadata:
  * @image: The image.
@@ -4022,46 +3922,6 @@ _gimp_image_get_metadata (GimpImage *image)
   return metadata_string;
 }
 
-/**
- * __gimp_image_get_metadata: (skip)
- * @image_ID: The image.
- *
- * Returns the image's metadata.
- *
- * Returns exif/iptc/xmp metadata from the image.
- *
- * Returns: The exif/ptc/xmp metadata as a string.
- *          The returned value must be freed with g_free().
- **/
-gchar *
-__gimp_image_get_metadata (gint32 image_ID)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gchar *metadata_string = NULL;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-metadata",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-metadata",
-                                            args);
-  gimp_value_array_unref (args);
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return metadata_string;
-}
-
 /**
  * _gimp_image_set_metadata:
  * @image: The image.
@@ -4103,47 +3963,6 @@ _gimp_image_set_metadata (GimpImage   *image,
   return success;
 }
 
-/**
- * __gimp_image_set_metadata: (skip)
- * @image_ID: The image.
- * @metadata_string: The exif/ptc/xmp metadata as a string.
- *
- * Set the image's metadata.
- *
- * Sets exif/iptc/xmp metadata on the image.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-__gimp_image_set_metadata (gint32       image_ID,
-                           const gchar *metadata_string)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_STRING, metadata_string,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-metadata",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-metadata",
-                                            args);
-  gimp_value_array_unref (args);
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  gimp_value_array_unref (return_vals);
-
-  return success;
-}
-
 /**
  * gimp_image_clean_all:
  * @image: The image.
@@ -4386,78 +4205,6 @@ _gimp_image_thumbnail (GimpImage  *image,
   return success;
 }
 
-/**
- * __gimp_image_thumbnail: (skip)
- * @image_ID: The image.
- * @width: The requested thumbnail width.
- * @height: The requested thumbnail height.
- * @actual_width: (out): The previews width.
- * @actual_height: (out): The previews height.
- * @bpp: (out): The previews bpp.
- * @thumbnail_data_count: (out): The number of bytes in thumbnail data.
- * @thumbnail_data: (out) (array length=thumbnail_data_count): The thumbnail data.
- *
- * Get a thumbnail of an image.
- *
- * This function gets data from which a thumbnail of an image preview
- * can be created. Maximum x or y dimension is 1024 pixels. The pixels
- * are returned in RGB[A] or GRAY[A] format. The bpp return value gives
- * the number of bits per pixel in the image.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-__gimp_image_thumbnail (gint32   image_ID,
-                        gint     width,
-                        gint     height,
-                        gint    *actual_width,
-                        gint    *actual_height,
-                        gint    *bpp,
-                        gint    *thumbnail_data_count,
-                        guint8 **thumbnail_data)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, width,
-                                          G_TYPE_INT, height,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-thumbnail",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-thumbnail",
-                                            args);
-  gimp_value_array_unref (args);
-
-  *actual_width = 0;
-  *actual_height = 0;
-  *bpp = 0;
-  *thumbnail_data_count = 0;
-  *thumbnail_data = NULL;
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  if (success)
-    {
-      *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
-      *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
-      *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
-      *thumbnail_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 5));
-    }
-
-  gimp_value_array_unref (return_vals);
-
-  return success;
-}
-
 /**
  * gimp_image_get_active_layer:
  * @image: The image.
diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h
index 0ade23a1f4..29a450fc04 100644
--- a/libgimp/gimpimage_pdb.h
+++ b/libgimp/gimpimage_pdb.h
@@ -237,13 +237,8 @@ gchar**                  gimp_image_get_parasite_list          (GimpImage
 #define gimp_image_flatten _gimp_image_flatten
 #define gimp_image_merge_visible_layers _gimp_image_merge_visible_layers
 #define gimp_image_merge_down _gimp_image_merge_down
-#define _gimp_image_get_colormap __gimp_image_get_colormap
-#define _gimp_image_set_colormap __gimp_image_set_colormap
-#define _gimp_image_get_metadata __gimp_image_get_metadata
-#define _gimp_image_set_metadata __gimp_image_set_metadata
 #define gimp_image_clean_all _gimp_image_clean_all
 #define gimp_image_is_dirty _gimp_image_is_dirty
-#define _gimp_image_thumbnail __gimp_image_thumbnail
 #define gimp_image_get_active_layer _gimp_image_get_active_layer
 #define gimp_image_set_active_layer _gimp_image_set_active_layer
 #define gimp_image_get_active_channel _gimp_image_get_active_channel
@@ -286,164 +281,148 @@ gchar**                  gimp_image_get_parasite_list          (GimpImage
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-gboolean          _gimp_image_is_valid                   (gint32               image_ID);
-gint32            _gimp_image_new                        (gint                 width,
-                                                          gint                 height,
-                                                          GimpImageBaseType    type);
-gint32            _gimp_image_new_with_precision         (gint                 width,
-                                                          gint                 height,
-                                                          GimpImageBaseType    type,
-                                                          GimpPrecision        precision);
-gint32            _gimp_image_duplicate                  (gint32               image_ID);
-gboolean          _gimp_image_delete                     (gint32               image_ID);
-GimpImageBaseType _gimp_image_base_type                  (gint32               image_ID);
-GimpPrecision     _gimp_image_get_precision              (gint32               image_ID);
-GimpLayerMode     _gimp_image_get_default_new_layer_mode (gint32               image_ID);
-gint              _gimp_image_width                      (gint32               image_ID);
-gint              _gimp_image_height                     (gint32               image_ID);
-gint*             _gimp_image_get_layers                 (gint32               image_ID,
-                                                          gint                *num_layers);
-gint*             _gimp_image_get_channels               (gint32               image_ID,
-                                                          gint                *num_channels);
-gint*             _gimp_image_get_vectors                (gint32               image_ID,
-                                                          gint                *num_vectors);
-gint32            _gimp_image_get_active_drawable        (gint32               image_ID);
-gboolean          _gimp_image_unset_active_channel       (gint32               image_ID);
-gint32            _gimp_image_get_floating_sel           (gint32               image_ID);
-gint32            _gimp_image_floating_sel_attached_to   (gint32               image_ID);
-gboolean          _gimp_image_pick_color                 (gint32               image_ID,
-                                                          gint32               drawable_ID,
-                                                          gdouble              x,
-                                                          gdouble              y,
-                                                          gboolean             sample_merged,
-                                                          gboolean             sample_average,
-                                                          gdouble              average_radius,
-                                                          GimpRGB             *color);
-gint32            _gimp_image_pick_correlate_layer       (gint32               image_ID,
-                                                          gint                 x,
-                                                          gint                 y);
-gboolean          _gimp_image_insert_layer               (gint32               image_ID,
-                                                          gint32               layer_ID,
-                                                          gint32               parent_ID,
-                                                          gint                 position);
-gboolean          _gimp_image_remove_layer               (gint32               image_ID,
-                                                          gint32               layer_ID);
-gboolean          _gimp_image_freeze_layers              (gint32               image_ID);
-gboolean          _gimp_image_thaw_layers                (gint32               image_ID);
-gboolean          _gimp_image_insert_channel             (gint32               image_ID,
-                                                          gint32               channel_ID,
-                                                          gint32               parent_ID,
-                                                          gint                 position);
-gboolean          _gimp_image_remove_channel             (gint32               image_ID,
-                                                          gint32               channel_ID);
-gboolean          _gimp_image_freeze_channels            (gint32               image_ID);
-gboolean          _gimp_image_thaw_channels              (gint32               image_ID);
-gboolean          _gimp_image_insert_vectors             (gint32               image_ID,
-                                                          gint32               vectors_ID,
-                                                          gint32               parent_ID,
-                                                          gint                 position);
-gboolean          _gimp_image_remove_vectors             (gint32               image_ID,
-                                                          gint32               vectors_ID);
-gboolean          _gimp_image_freeze_vectors             (gint32               image_ID);
-gboolean          _gimp_image_thaw_vectors               (gint32               image_ID);
-gint              _gimp_image_get_item_position          (gint32               image_ID,
-                                                          gint32               item_ID);
-gboolean          _gimp_image_raise_item                 (gint32               image_ID,
-                                                          gint32               item_ID);
-gboolean          _gimp_image_lower_item                 (gint32               image_ID,
-                                                          gint32               item_ID);
-gboolean          _gimp_image_raise_item_to_top          (gint32               image_ID,
-                                                          gint32               item_ID);
-gboolean          _gimp_image_lower_item_to_bottom       (gint32               image_ID,
-                                                          gint32               item_ID);
-gboolean          _gimp_image_reorder_item               (gint32               image_ID,
-                                                          gint32               item_ID,
-                                                          gint32               parent_ID,
-                                                          gint                 position);
-gint32            _gimp_image_flatten                    (gint32               image_ID);
-gint32            _gimp_image_merge_visible_layers       (gint32               image_ID,
-                                                          GimpMergeType        merge_type);
-gint32            _gimp_image_merge_down                 (gint32               image_ID,
-                                                          gint32               merge_layer_ID,
-                                                          GimpMergeType        merge_type);
-guint8*           __gimp_image_get_colormap              (gint32               image_ID,
-                                                          gint                *num_bytes);
-gboolean          __gimp_image_set_colormap              (gint32               image_ID,
-                                                          gint                 num_bytes,
-                                                          const guint8        *colormap);
-gchar*            __gimp_image_get_metadata              (gint32               image_ID);
-gboolean          __gimp_image_set_metadata              (gint32               image_ID,
-                                                          const gchar         *metadata_string);
-gboolean          _gimp_image_clean_all                  (gint32               image_ID);
-gboolean          _gimp_image_is_dirty                   (gint32               image_ID);
-gboolean          __gimp_image_thumbnail                 (gint32               image_ID,
-                                                          gint                 width,
-                                                          gint                 height,
-                                                          gint                *actual_width,
-                                                          gint                *actual_height,
-                                                          gint                *bpp,
-                                                          gint                *thumbnail_data_count,
-                                                          guint8             **thumbnail_data);
-gint32            _gimp_image_get_active_layer           (gint32               image_ID);
-gboolean          _gimp_image_set_active_layer           (gint32               image_ID,
-                                                          gint32               active_layer_ID);
-gint32            _gimp_image_get_active_channel         (gint32               image_ID);
-gboolean          _gimp_image_set_active_channel         (gint32               image_ID,
-                                                          gint32               active_channel_ID);
-gint32            _gimp_image_get_active_vectors         (gint32               image_ID);
-gboolean          _gimp_image_set_active_vectors         (gint32               image_ID,
-                                                          gint32               active_vectors_ID);
-gint32            _gimp_image_get_selection              (gint32               image_ID);
-gboolean          _gimp_image_get_component_active       (gint32               image_ID,
-                                                          GimpChannelType      component);
-gboolean          _gimp_image_set_component_active       (gint32               image_ID,
-                                                          GimpChannelType      component,
-                                                          gboolean             active);
-gboolean          _gimp_image_get_component_visible      (gint32               image_ID,
-                                                          GimpChannelType      component);
-gboolean          _gimp_image_set_component_visible      (gint32               image_ID,
-                                                          GimpChannelType      component,
-                                                          gboolean             visible);
-gchar*            _gimp_image_get_filename               (gint32               image_ID);
-gboolean          _gimp_image_set_filename               (gint32               image_ID,
-                                                          const gchar         *filename);
-gchar*            _gimp_image_get_uri                    (gint32               image_ID);
-gchar*            _gimp_image_get_xcf_uri                (gint32               image_ID);
-gchar*            _gimp_image_get_imported_uri           (gint32               image_ID);
-gchar*            _gimp_image_get_exported_uri           (gint32               image_ID);
-gchar*            _gimp_image_get_name                   (gint32               image_ID);
-gboolean          _gimp_image_get_resolution             (gint32               image_ID,
-                                                          gdouble             *xresolution,
-                                                          gdouble             *yresolution);
-gboolean          _gimp_image_set_resolution             (gint32               image_ID,
-                                                          gdouble              xresolution,
-                                                          gdouble              yresolution);
-GimpUnit          _gimp_image_get_unit                   (gint32               image_ID);
-gboolean          _gimp_image_set_unit                   (gint32               image_ID,
-                                                          GimpUnit             unit);
-guint             _gimp_image_get_tattoo_state           (gint32               image_ID);
-gboolean          _gimp_image_set_tattoo_state           (gint32               image_ID,
-                                                          guint                tattoo_state);
-gint32            _gimp_image_get_layer_by_tattoo        (gint32               image_ID,
-                                                          guint                tattoo);
-gint32            _gimp_image_get_channel_by_tattoo      (gint32               image_ID,
-                                                          guint                tattoo);
-gint32            _gimp_image_get_vectors_by_tattoo      (gint32               image_ID,
-                                                          guint                tattoo);
-gint32            _gimp_image_get_layer_by_name          (gint32               image_ID,
-                                                          const gchar         *name);
-gint32            _gimp_image_get_channel_by_name        (gint32               image_ID,
-                                                          const gchar         *name);
-gint32            _gimp_image_get_vectors_by_name        (gint32               image_ID,
-                                                          const gchar         *name);
-gboolean          _gimp_image_attach_parasite            (gint32               image_ID,
-                                                          const GimpParasite  *parasite);
-gboolean          _gimp_image_detach_parasite            (gint32               image_ID,
-                                                          const gchar         *name);
-GimpParasite*     _gimp_image_get_parasite               (gint32               image_ID,
-                                                          const gchar         *name);
-gchar**           _gimp_image_get_parasite_list          (gint32               image_ID,
-                                                          gint                *num_parasites);
+gboolean          _gimp_image_is_valid                   (gint32              image_ID);
+gint32            _gimp_image_new                        (gint                width,
+                                                          gint                height,
+                                                          GimpImageBaseType   type);
+gint32            _gimp_image_new_with_precision         (gint                width,
+                                                          gint                height,
+                                                          GimpImageBaseType   type,
+                                                          GimpPrecision       precision);
+gint32            _gimp_image_duplicate                  (gint32              image_ID);
+gboolean          _gimp_image_delete                     (gint32              image_ID);
+GimpImageBaseType _gimp_image_base_type                  (gint32              image_ID);
+GimpPrecision     _gimp_image_get_precision              (gint32              image_ID);
+GimpLayerMode     _gimp_image_get_default_new_layer_mode (gint32              image_ID);
+gint              _gimp_image_width                      (gint32              image_ID);
+gint              _gimp_image_height                     (gint32              image_ID);
+gint*             _gimp_image_get_layers                 (gint32              image_ID,
+                                                          gint               *num_layers);
+gint*             _gimp_image_get_channels               (gint32              image_ID,
+                                                          gint               *num_channels);
+gint*             _gimp_image_get_vectors                (gint32              image_ID,
+                                                          gint               *num_vectors);
+gint32            _gimp_image_get_active_drawable        (gint32              image_ID);
+gboolean          _gimp_image_unset_active_channel       (gint32              image_ID);
+gint32            _gimp_image_get_floating_sel           (gint32              image_ID);
+gint32            _gimp_image_floating_sel_attached_to   (gint32              image_ID);
+gboolean          _gimp_image_pick_color                 (gint32              image_ID,
+                                                          gint32              drawable_ID,
+                                                          gdouble             x,
+                                                          gdouble             y,
+                                                          gboolean            sample_merged,
+                                                          gboolean            sample_average,
+                                                          gdouble             average_radius,
+                                                          GimpRGB            *color);
+gint32            _gimp_image_pick_correlate_layer       (gint32              image_ID,
+                                                          gint                x,
+                                                          gint                y);
+gboolean          _gimp_image_insert_layer               (gint32              image_ID,
+                                                          gint32              layer_ID,
+                                                          gint32              parent_ID,
+                                                          gint                position);
+gboolean          _gimp_image_remove_layer               (gint32              image_ID,
+                                                          gint32              layer_ID);
+gboolean          _gimp_image_freeze_layers              (gint32              image_ID);
+gboolean          _gimp_image_thaw_layers                (gint32              image_ID);
+gboolean          _gimp_image_insert_channel             (gint32              image_ID,
+                                                          gint32              channel_ID,
+                                                          gint32              parent_ID,
+                                                          gint                position);
+gboolean          _gimp_image_remove_channel             (gint32              image_ID,
+                                                          gint32              channel_ID);
+gboolean          _gimp_image_freeze_channels            (gint32              image_ID);
+gboolean          _gimp_image_thaw_channels              (gint32              image_ID);
+gboolean          _gimp_image_insert_vectors             (gint32              image_ID,
+                                                          gint32              vectors_ID,
+                                                          gint32              parent_ID,
+                                                          gint                position);
+gboolean          _gimp_image_remove_vectors             (gint32              image_ID,
+                                                          gint32              vectors_ID);
+gboolean          _gimp_image_freeze_vectors             (gint32              image_ID);
+gboolean          _gimp_image_thaw_vectors               (gint32              image_ID);
+gint              _gimp_image_get_item_position          (gint32              image_ID,
+                                                          gint32              item_ID);
+gboolean          _gimp_image_raise_item                 (gint32              image_ID,
+                                                          gint32              item_ID);
+gboolean          _gimp_image_lower_item                 (gint32              image_ID,
+                                                          gint32              item_ID);
+gboolean          _gimp_image_raise_item_to_top          (gint32              image_ID,
+                                                          gint32              item_ID);
+gboolean          _gimp_image_lower_item_to_bottom       (gint32              image_ID,
+                                                          gint32              item_ID);
+gboolean          _gimp_image_reorder_item               (gint32              image_ID,
+                                                          gint32              item_ID,
+                                                          gint32              parent_ID,
+                                                          gint                position);
+gint32            _gimp_image_flatten                    (gint32              image_ID);
+gint32            _gimp_image_merge_visible_layers       (gint32              image_ID,
+                                                          GimpMergeType       merge_type);
+gint32            _gimp_image_merge_down                 (gint32              image_ID,
+                                                          gint32              merge_layer_ID,
+                                                          GimpMergeType       merge_type);
+gboolean          _gimp_image_clean_all                  (gint32              image_ID);
+gboolean          _gimp_image_is_dirty                   (gint32              image_ID);
+gint32            _gimp_image_get_active_layer           (gint32              image_ID);
+gboolean          _gimp_image_set_active_layer           (gint32              image_ID,
+                                                          gint32              active_layer_ID);
+gint32            _gimp_image_get_active_channel         (gint32              image_ID);
+gboolean          _gimp_image_set_active_channel         (gint32              image_ID,
+                                                          gint32              active_channel_ID);
+gint32            _gimp_image_get_active_vectors         (gint32              image_ID);
+gboolean          _gimp_image_set_active_vectors         (gint32              image_ID,
+                                                          gint32              active_vectors_ID);
+gint32            _gimp_image_get_selection              (gint32              image_ID);
+gboolean          _gimp_image_get_component_active       (gint32              image_ID,
+                                                          GimpChannelType     component);
+gboolean          _gimp_image_set_component_active       (gint32              image_ID,
+                                                          GimpChannelType     component,
+                                                          gboolean            active);
+gboolean          _gimp_image_get_component_visible      (gint32              image_ID,
+                                                          GimpChannelType     component);
+gboolean          _gimp_image_set_component_visible      (gint32              image_ID,
+                                                          GimpChannelType     component,
+                                                          gboolean            visible);
+gchar*            _gimp_image_get_filename               (gint32              image_ID);
+gboolean          _gimp_image_set_filename               (gint32              image_ID,
+                                                          const gchar        *filename);
+gchar*            _gimp_image_get_uri                    (gint32              image_ID);
+gchar*            _gimp_image_get_xcf_uri                (gint32              image_ID);
+gchar*            _gimp_image_get_imported_uri           (gint32              image_ID);
+gchar*            _gimp_image_get_exported_uri           (gint32              image_ID);
+gchar*            _gimp_image_get_name                   (gint32              image_ID);
+gboolean          _gimp_image_get_resolution             (gint32              image_ID,
+                                                          gdouble            *xresolution,
+                                                          gdouble            *yresolution);
+gboolean          _gimp_image_set_resolution             (gint32              image_ID,
+                                                          gdouble             xresolution,
+                                                          gdouble             yresolution);
+GimpUnit          _gimp_image_get_unit                   (gint32              image_ID);
+gboolean          _gimp_image_set_unit                   (gint32              image_ID,
+                                                          GimpUnit            unit);
+guint             _gimp_image_get_tattoo_state           (gint32              image_ID);
+gboolean          _gimp_image_set_tattoo_state           (gint32              image_ID,
+                                                          guint               tattoo_state);
+gint32            _gimp_image_get_layer_by_tattoo        (gint32              image_ID,
+                                                          guint               tattoo);
+gint32            _gimp_image_get_channel_by_tattoo      (gint32              image_ID,
+                                                          guint               tattoo);
+gint32            _gimp_image_get_vectors_by_tattoo      (gint32              image_ID,
+                                                          guint               tattoo);
+gint32            _gimp_image_get_layer_by_name          (gint32              image_ID,
+                                                          const gchar        *name);
+gint32            _gimp_image_get_channel_by_name        (gint32              image_ID,
+                                                          const gchar        *name);
+gint32            _gimp_image_get_vectors_by_name        (gint32              image_ID,
+                                                          const gchar        *name);
+gboolean          _gimp_image_attach_parasite            (gint32              image_ID,
+                                                          const GimpParasite *parasite);
+gboolean          _gimp_image_detach_parasite            (gint32              image_ID,
+                                                          const gchar        *name);
+GimpParasite*     _gimp_image_get_parasite               (gint32              image_ID,
+                                                          const gchar        *name);
+gchar**           _gimp_image_get_parasite_list          (gint32              image_ID,
+                                                          gint               *num_parasites);
 
 
 G_END_DECLS
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index 921cac6cc2..48a9092d71 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -85,56 +85,6 @@ _gimp_image_get_color_profile (GimpImage *image,
   return profile_data;
 }
 
-/**
- * __gimp_image_get_color_profile: (skip)
- * @image_ID: The image.
- * @num_bytes: (out): Number of bytes in the color_profile array.
- *
- * Returns the image's color profile
- *
- * This procedure returns the image's color profile, or NULL if the
- * image has no color profile assigned.
- *
- * Returns: (array length=num_bytes): The image's serialized color profile.
- *          The returned value must be freed with g_free().
- *
- * Since: 2.10
- **/
-guint8 *
-__gimp_image_get_color_profile (gint32  image_ID,
-                                gint   *num_bytes)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  guint8 *profile_data = NULL;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-color-profile",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-color-profile",
-                                            args);
-  gimp_value_array_unref (args);
-
-  *num_bytes = 0;
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
-    }
-
-  gimp_value_array_unref (return_vals);
-
-  return profile_data;
-}
-
 /**
  * _gimp_image_get_effective_color_profile:
  * @image: The image.
@@ -189,59 +139,6 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
   return profile_data;
 }
 
-/**
- * __gimp_image_get_effective_color_profile: (skip)
- * @image_ID: The image.
- * @num_bytes: (out): Number of bytes in the color_profile array.
- *
- * Returns the color profile that is used for the image
- *
- * This procedure returns the color profile that is actually used for
- * this image, which is the profile returned by
- * gimp_image_get_color_profile() if the image has a profile assigned,
- * or a generated default RGB or grayscale profile, according to the
- * image's type.
- *
- * Returns: (array length=num_bytes): The image's serialized color profile.
- *          The returned value must be freed with g_free().
- *
- * Since: 2.10
- **/
-guint8 *
-__gimp_image_get_effective_color_profile (gint32  image_ID,
-                                          gint   *num_bytes)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  guint8 *profile_data = NULL;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-get-effective-color-profile",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-get-effective-color-profile",
-                                            args);
-  gimp_value_array_unref (args);
-
-  *num_bytes = 0;
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    {
-      *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
-      profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2));
-    }
-
-  gimp_value_array_unref (return_vals);
-
-  return profile_data;
-}
-
 /**
  * _gimp_image_set_color_profile:
  * @image: The image.
@@ -293,57 +190,6 @@ _gimp_image_set_color_profile (GimpImage    *image,
   return success;
 }
 
-/**
- * __gimp_image_set_color_profile: (skip)
- * @image_ID: The image.
- * @num_bytes: Number of bytes in the color_profile array.
- * @color_profile: (array length=num_bytes) (element-type guint8): The new serialized color profile.
- *
- * Sets the image's color profile
- *
- * This procedure sets the image's color profile, or unsets it if NULL
- * is passed as 'color_profile'. This procedure does no color
- * conversion. However, it will change the pixel format of all layers
- * to contain the babl space matching the profile. You must call this
- * procedure before adding layers to the image.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.10
- **/
-gboolean
-__gimp_image_set_color_profile (gint32        image_ID,
-                                gint          num_bytes,
-                                const guint8 *color_profile)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, num_bytes,
-                                          GIMP_TYPE_UINT8_ARRAY, NULL,
-                                          G_TYPE_NONE);
-  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-set-color-profile",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile",
-                                            args);
-  gimp_value_array_unref (args);
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  gimp_value_array_unref (return_vals);
-
-  return success;
-}
-
 /**
  * gimp_image_set_color_profile_from_file:
  * @image: The image.
@@ -496,62 +342,6 @@ _gimp_image_convert_color_profile (GimpImage                *image,
   return success;
 }
 
-/**
- * __gimp_image_convert_color_profile: (skip)
- * @image_ID: The image.
- * @num_bytes: Number of bytes in the color_profile array.
- * @color_profile: (array length=num_bytes) (element-type guint8): The serialized color profile.
- * @intent: Rendering intent.
- * @bpc: Black point compensation.
- *
- * Convert the image's layers to a color profile
- *
- * This procedure converts from the image's color profile (or the
- * default RGB or grayscale profile if none is set) to the given color
- * profile. Only RGB and grayscale color profiles are accepted,
- * according to the image's type.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.10
- **/
-gboolean
-__gimp_image_convert_color_profile (gint32                    image_ID,
-                                    gint                      num_bytes,
-                                    const guint8             *color_profile,
-                                    GimpColorRenderingIntent  intent,
-                                    gboolean                  bpc)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, num_bytes,
-                                          GIMP_TYPE_UINT8_ARRAY, NULL,
-                                          GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
-                                          G_TYPE_BOOLEAN, bpc,
-                                          G_TYPE_NONE);
-  gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-image-convert-color-profile",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile",
-                                            args);
-  gimp_value_array_unref (args);
-
-  success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
-
-  gimp_value_array_unref (return_vals);
-
-  return success;
-}
-
 /**
  * gimp_image_convert_color_profile_from_file:
  * @image: The image.
diff --git a/libgimp/gimpimagecolorprofile_pdb.h b/libgimp/gimpimagecolorprofile_pdb.h
index 601769a53b..ce9b08e86d 100644
--- a/libgimp/gimpimagecolorprofile_pdb.h
+++ b/libgimp/gimpimagecolorprofile_pdb.h
@@ -57,11 +57,7 @@ gboolean                 gimp_image_convert_color_profile_from_file (GimpImage
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
-#define _gimp_image_get_color_profile __gimp_image_get_color_profile
-#define _gimp_image_get_effective_color_profile __gimp_image_get_effective_color_profile
-#define _gimp_image_set_color_profile __gimp_image_set_color_profile
 #define gimp_image_set_color_profile_from_file _gimp_image_set_color_profile_from_file
-#define _gimp_image_convert_color_profile __gimp_image_convert_color_profile
 #define gimp_image_convert_color_profile_from_file _gimp_image_convert_color_profile_from_file
 
 
@@ -71,20 +67,8 @@ gboolean                 gimp_image_convert_color_profile_from_file (GimpImage
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-guint8*  __gimp_image_get_color_profile              (gint32                    image_ID,
-                                                      gint                     *num_bytes);
-guint8*  __gimp_image_get_effective_color_profile    (gint32                    image_ID,
-                                                      gint                     *num_bytes);
-gboolean __gimp_image_set_color_profile              (gint32                    image_ID,
-                                                      gint                      num_bytes,
-                                                      const guint8             *color_profile);
 gboolean _gimp_image_set_color_profile_from_file     (gint32                    image_ID,
                                                       const gchar              *uri);
-gboolean __gimp_image_convert_color_profile          (gint32                    image_ID,
-                                                      gint                      num_bytes,
-                                                      const guint8             *color_profile,
-                                                      GimpColorRenderingIntent  intent,
-                                                      gboolean                  bpc);
 gboolean _gimp_image_convert_color_profile_from_file (gint32                    image_ID,
                                                       const gchar              *uri,
                                                       GimpColorRenderingIntent  intent,
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 658972ecd5..4071746d70 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -96,68 +96,6 @@ _gimp_layer_new (GimpImage     *image,
   return layer;
 }
 
-/**
- * __gimp_layer_new: (skip)
- * @image_ID: The image to which to add the layer.
- * @width: The layer width.
- * @height: The layer height.
- * @type: The layer type.
- * @name: The layer name.
- * @opacity: The layer opacity.
- * @mode: The layer combination mode.
- *
- * Create a new layer.
- *
- * This procedure creates a new layer with the specified width, height,
- * and type. Name, opacity, and mode are also supplied parameters. The
- * new layer still needs to be added to the image, as this is not
- * automatic. Add the new layer with the gimp_image_insert_layer()
- * command. Other attributes such as layer mask modes, and offsets
- * should be set with explicit procedure calls.
- *
- * Returns: The newly created layer.
- **/
-gint32
-__gimp_layer_new (gint32         image_ID,
-                  gint           width,
-                  gint           height,
-                  GimpImageType  type,
-                  const gchar   *name,
-                  gdouble        opacity,
-                  GimpLayerMode  mode)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_IMAGE_ID, image_ID,
-                                          G_TYPE_INT, width,
-                                          G_TYPE_INT, height,
-                                          GIMP_TYPE_IMAGE_TYPE, type,
-                                          G_TYPE_STRING, name,
-                                          G_TYPE_DOUBLE, opacity,
-                                          GIMP_TYPE_LAYER_MODE, mode,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-layer-new",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-layer-new",
-                                            args);
-  gimp_value_array_unref (args);
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return layer_ID;
-}
-
 /**
  * gimp_layer_new_from_visible:
  * @image: The source image from where the content is copied.
@@ -493,53 +431,6 @@ _gimp_layer_copy (GimpLayer *layer,
   return layer_copy;
 }
 
-/**
- * __gimp_layer_copy: (skip)
- * @layer_ID: 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: The newly copied layer.
- **/
-gint32
-__gimp_layer_copy (gint32   layer_ID,
-                   gboolean add_alpha)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gint32 layer_copy_ID = -1;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_LAYER_ID, layer_ID,
-                                          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_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return layer_copy_ID;
-}
-
 /**
  * gimp_layer_add_alpha:
  * @layer: The layer.
diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h
index fd24228e62..a06e6f5686 100644
--- a/libgimp/gimplayer_pdb.h
+++ b/libgimp/gimplayer_pdb.h
@@ -105,11 +105,9 @@ gboolean                   gimp_layer_set_composite_mode   (GimpLayer
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
-#define _gimp_layer_new __gimp_layer_new
 #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
@@ -148,21 +146,12 @@ gboolean                   gimp_layer_set_composite_mode   (GimpLayer
  * 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_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,
diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c
index 0ff8a45d86..4d12c94f88 100644
--- a/libgimp/gimpprogress_pdb.c
+++ b/libgimp/gimpprogress_pdb.c
@@ -76,48 +76,6 @@ _gimp_progress_init (const gchar *message,
   return success;
 }
 
-/**
- * __gimp_progress_init: (skip)
- * @message: Message to use in the progress dialog.
- * @gdisplay_ID: GimpDisplay to update progressbar in, or -1 for a separate window.
- *
- * Initializes the progress bar for the current plug-in.
- *
- * Initializes the progress bar for the current plug-in. It is only
- * valid to call this procedure from a plug-in.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-__gimp_progress_init (const gchar *message,
-                      gint32       gdisplay_ID)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gboolean success = TRUE;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          G_TYPE_STRING, message,
-                                          GIMP_TYPE_DISPLAY_ID, gdisplay_ID,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-progress-init",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-progress-init",
-                                            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_progress_update:
  * @percentage: Percentage of progress completed which must be between 0.0 and 1.0.
diff --git a/libgimp/gimpprogress_pdb.h b/libgimp/gimpprogress_pdb.h
index 2870d9c057..d75fc732ea 100644
--- a/libgimp/gimpprogress_pdb.h
+++ b/libgimp/gimpprogress_pdb.h
@@ -48,7 +48,6 @@ G_GNUC_INTERNAL gboolean _gimp_progress_init (const gchar *message,
 
 #else /* GIMP_DEPRECATED_REPLACE_NEW_API */
 
-#define _gimp_progress_init __gimp_progress_init
 
 
 #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */
@@ -57,8 +56,7 @@ G_GNUC_INTERNAL gboolean _gimp_progress_init (const gchar *message,
  * They are not marked internal as a trick to keep the old API alive for now.
  */
 
-gboolean __gimp_progress_init (const gchar *message,
-                               gint32       gdisplay_ID);
+
 
 
 G_END_DECLS
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index c85c2d9f54..6838dcbda4 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -492,56 +492,6 @@ _gimp_selection_float (GimpDrawable *drawable,
   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.
- *
- * Float the selection from the specified drawable with initial offsets
- * as specified.
- *
- * This procedure determines the region of the specified drawable that
- * lies beneath the current selection. The region is then cut from the
- * drawable and the resulting data is made into a new layer which is
- * instantiated as a floating selection. The offsets allow initial
- * positioning of the new floating selection.
- *
- * Returns: The floated layer.
- **/
-gint32
-__gimp_selection_float (gint32 drawable_ID,
-                        gint   offx,
-                        gint   offy)
-{
-  GimpPDB        *pdb = gimp_get_pdb ();
-  GimpValueArray *args;
-  GimpValueArray *return_vals;
-  gint32 layer_ID = -1;
-
-  args = gimp_value_array_new_from_types (NULL,
-                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
-                                          G_TYPE_INT, offx,
-                                          G_TYPE_INT, offy,
-                                          G_TYPE_NONE);
-
-  if (pdb)
-    return_vals = gimp_pdb_run_procedure_array (pdb,
-                                                "gimp-selection-float",
-                                                args);
-  else
-    return_vals = gimp_run_procedure_array ("gimp-selection-float",
-                                            args);
-  gimp_value_array_unref (args);
-
-  if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
-    layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
-
-  gimp_value_array_unref (return_vals);
-
-  return layer_ID;
-}
-
 /**
  * gimp_selection_invert:
  * @image: The image.
diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h
index eca4fc82f8..287df8875d 100644
--- a/libgimp/gimpselection_pdb.h
+++ b/libgimp/gimpselection_pdb.h
@@ -73,7 +73,6 @@ GimpChannel*               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
@@ -105,9 +104,6 @@ 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/pdb/lib.pl b/pdb/lib.pl
index 706635d14d..7a0a6ff414 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -89,6 +89,10 @@ sub generate_fun {
     my $func_annotations = "";
 
     if ($proc->{lib_private}) {
+        if ($api_deprecated) {
+            # No need to create deprecated versions of private libs.
+            return '';
+        }
         $wrapped = '_';
     }
 



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