[gimp] libgimpbase: sort gimpbaseenums.h alphabetically



commit 9dde82b215b7a7112981b20892745dc2a068d17a
Author: Michael Natterer <mitch gimp org>
Date:   Tue May 13 23:29:17 2014 +0200

    libgimpbase: sort gimpbaseenums.h alphabetically

 libgimpbase/gimpbaseenums.c |  696 +++++++++++++++++++++---------------------
 libgimpbase/gimpbaseenums.h |  376 ++++++++++++------------
 tools/pdbgen/enums.pl       |  320 ++++++++++----------
 3 files changed, 696 insertions(+), 696 deletions(-)
---
diff --git a/libgimpbase/gimpbaseenums.c b/libgimpbase/gimpbaseenums.c
index e62f127..5a1afaf 100644
--- a/libgimpbase/gimpbaseenums.c
+++ b/libgimpbase/gimpbaseenums.c
@@ -289,27 +289,19 @@ gimp_check_type_get_type (void)
 }
 
 GType
-gimp_component_type_get_type (void)
+gimp_clone_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_COMPONENT_TYPE_U8, "GIMP_COMPONENT_TYPE_U8", "u8" },
-    { GIMP_COMPONENT_TYPE_U16, "GIMP_COMPONENT_TYPE_U16", "u16" },
-    { GIMP_COMPONENT_TYPE_U32, "GIMP_COMPONENT_TYPE_U32", "u32" },
-    { GIMP_COMPONENT_TYPE_HALF, "GIMP_COMPONENT_TYPE_HALF", "half" },
-    { GIMP_COMPONENT_TYPE_FLOAT, "GIMP_COMPONENT_TYPE_FLOAT", "float" },
-    { GIMP_COMPONENT_TYPE_DOUBLE, "GIMP_COMPONENT_TYPE_DOUBLE", "double" },
+    { GIMP_CLONE_IMAGE, "GIMP_CLONE_IMAGE", "image-clone" },
+    { GIMP_CLONE_PATTERN, "GIMP_CLONE_PATTERN", "pattern-clone" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_COMPONENT_TYPE_U8, NC_("component-type", "8-bit integer"), NULL },
-    { GIMP_COMPONENT_TYPE_U16, NC_("component-type", "16-bit integer"), NULL },
-    { GIMP_COMPONENT_TYPE_U32, NC_("component-type", "32-bit integer"), NULL },
-    { GIMP_COMPONENT_TYPE_HALF, NC_("component-type", "16-bit floating point"), NULL },
-    { GIMP_COMPONENT_TYPE_FLOAT, NC_("component-type", "32-bit floating point"), NULL },
-    { GIMP_COMPONENT_TYPE_DOUBLE, NC_("component-type", "64-bit floating point"), NULL },
+    { GIMP_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
+    { GIMP_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -317,9 +309,9 @@ gimp_component_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpComponentType", values);
+      type = g_enum_register_static ("GimpCloneType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "component-type");
+      gimp_type_set_translation_context (type, "clone-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -327,19 +319,27 @@ gimp_component_type_get_type (void)
 }
 
 GType
-gimp_convolve_type_get_type (void)
+gimp_component_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CONVOLVE_BLUR, "GIMP_CONVOLVE_BLUR", "blur-convolve" },
-    { GIMP_CONVOLVE_SHARPEN, "GIMP_CONVOLVE_SHARPEN", "sharpen-convolve" },
+    { GIMP_COMPONENT_TYPE_U8, "GIMP_COMPONENT_TYPE_U8", "u8" },
+    { GIMP_COMPONENT_TYPE_U16, "GIMP_COMPONENT_TYPE_U16", "u16" },
+    { GIMP_COMPONENT_TYPE_U32, "GIMP_COMPONENT_TYPE_U32", "u32" },
+    { GIMP_COMPONENT_TYPE_HALF, "GIMP_COMPONENT_TYPE_HALF", "half" },
+    { GIMP_COMPONENT_TYPE_FLOAT, "GIMP_COMPONENT_TYPE_FLOAT", "float" },
+    { GIMP_COMPONENT_TYPE_DOUBLE, "GIMP_COMPONENT_TYPE_DOUBLE", "double" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_CONVOLVE_BLUR, NC_("convolve-type", "Blur"), NULL },
-    { GIMP_CONVOLVE_SHARPEN, NC_("convolve-type", "Sharpen"), NULL },
+    { GIMP_COMPONENT_TYPE_U8, NC_("component-type", "8-bit integer"), NULL },
+    { GIMP_COMPONENT_TYPE_U16, NC_("component-type", "16-bit integer"), NULL },
+    { GIMP_COMPONENT_TYPE_U32, NC_("component-type", "32-bit integer"), NULL },
+    { GIMP_COMPONENT_TYPE_HALF, NC_("component-type", "16-bit floating point"), NULL },
+    { GIMP_COMPONENT_TYPE_FLOAT, NC_("component-type", "32-bit floating point"), NULL },
+    { GIMP_COMPONENT_TYPE_DOUBLE, NC_("component-type", "64-bit floating point"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -347,9 +347,9 @@ gimp_convolve_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpConvolveType", values);
+      type = g_enum_register_static ("GimpComponentType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "convolve-type");
+      gimp_type_set_translation_context (type, "component-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -357,19 +357,19 @@ gimp_convolve_type_get_type (void)
 }
 
 GType
-gimp_clone_type_get_type (void)
+gimp_convolve_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CLONE_IMAGE, "GIMP_CLONE_IMAGE", "image-clone" },
-    { GIMP_CLONE_PATTERN, "GIMP_CLONE_PATTERN", "pattern-clone" },
+    { GIMP_CONVOLVE_BLUR, "GIMP_CONVOLVE_BLUR", "blur-convolve" },
+    { GIMP_CONVOLVE_SHARPEN, "GIMP_CONVOLVE_SHARPEN", "sharpen-convolve" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
-    { GIMP_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
+    { GIMP_CONVOLVE_BLUR, NC_("convolve-type", "Blur"), NULL },
+    { GIMP_CONVOLVE_SHARPEN, NC_("convolve-type", "Sharpen"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -377,9 +377,9 @@ gimp_clone_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpCloneType", values);
+      type = g_enum_register_static ("GimpConvolveType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "clone-type");
+      gimp_type_set_translation_context (type, "convolve-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -515,37 +515,21 @@ gimp_foreground_extract_mode_get_type (void)
 }
 
 GType
-gimp_gradient_type_get_type (void)
+gimp_gradient_segment_color_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_GRADIENT_LINEAR, "GIMP_GRADIENT_LINEAR", "linear" },
-    { GIMP_GRADIENT_BILINEAR, "GIMP_GRADIENT_BILINEAR", "bilinear" },
-    { GIMP_GRADIENT_RADIAL, "GIMP_GRADIENT_RADIAL", "radial" },
-    { GIMP_GRADIENT_SQUARE, "GIMP_GRADIENT_SQUARE", "square" },
-    { GIMP_GRADIENT_CONICAL_SYMMETRIC, "GIMP_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
-    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, "GIMP_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
-    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, "GIMP_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
-    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, "GIMP_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
-    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, "GIMP_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
-    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, "GIMP_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
-    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, "GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
+    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", "rgb" },
+    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
+    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_GRADIENT_LINEAR, NC_("gradient-type", "Linear"), NULL },
-    { GIMP_GRADIENT_BILINEAR, NC_("gradient-type", "Bi-linear"), NULL },
-    { GIMP_GRADIENT_RADIAL, NC_("gradient-type", "Radial"), NULL },
-    { GIMP_GRADIENT_SQUARE, NC_("gradient-type", "Square"), NULL },
-    { GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (sym)"), NULL },
-    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asym)"), NULL },
-    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, NC_("gradient-type", "Shaped (angular)"), NULL },
-    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, NC_("gradient-type", "Shaped (spherical)"), NULL },
-    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, NC_("gradient-type", "Shaped (dimpled)"), NULL },
-    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (cw)"), NULL },
-    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (ccw)"), NULL },
+    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", NULL },
+    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", NULL },
+    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", NULL },
     { 0, NULL, NULL }
   };
 
@@ -553,9 +537,9 @@ gimp_gradient_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpGradientType", values);
+      type = g_enum_register_static ("GimpGradientSegmentColor", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "gradient-type");
+      gimp_type_set_translation_context (type, "gradient-segment-color");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -563,21 +547,25 @@ gimp_gradient_type_get_type (void)
 }
 
 GType
-gimp_gradient_segment_color_get_type (void)
+gimp_gradient_segment_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", "rgb" },
-    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
-    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
+    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", "linear" },
+    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", "curved" },
+    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", "sine" },
+    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", 
"sphere-increasing" },
+    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", 
"sphere-decreasing" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", NULL },
-    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", NULL },
-    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", NULL },
+    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", NULL },
+    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", NULL },
+    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", NULL },
+    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", NULL },
+    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", NULL },
     { 0, NULL, NULL }
   };
 
@@ -585,9 +573,9 @@ gimp_gradient_segment_color_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpGradientSegmentColor", values);
+      type = g_enum_register_static ("GimpGradientSegmentType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "gradient-segment-color");
+      gimp_type_set_translation_context (type, "gradient-segment-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -595,25 +583,37 @@ gimp_gradient_segment_color_get_type (void)
 }
 
 GType
-gimp_gradient_segment_type_get_type (void)
+gimp_gradient_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", "linear" },
-    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", "curved" },
-    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", "sine" },
-    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", 
"sphere-increasing" },
-    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", 
"sphere-decreasing" },
+    { GIMP_GRADIENT_LINEAR, "GIMP_GRADIENT_LINEAR", "linear" },
+    { GIMP_GRADIENT_BILINEAR, "GIMP_GRADIENT_BILINEAR", "bilinear" },
+    { GIMP_GRADIENT_RADIAL, "GIMP_GRADIENT_RADIAL", "radial" },
+    { GIMP_GRADIENT_SQUARE, "GIMP_GRADIENT_SQUARE", "square" },
+    { GIMP_GRADIENT_CONICAL_SYMMETRIC, "GIMP_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
+    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, "GIMP_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
+    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, "GIMP_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
+    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, "GIMP_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
+    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, "GIMP_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
+    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, "GIMP_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
+    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, "GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", NULL },
-    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", NULL },
-    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", NULL },
-    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", NULL },
-    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", NULL },
+    { GIMP_GRADIENT_LINEAR, NC_("gradient-type", "Linear"), NULL },
+    { GIMP_GRADIENT_BILINEAR, NC_("gradient-type", "Bi-linear"), NULL },
+    { GIMP_GRADIENT_RADIAL, NC_("gradient-type", "Radial"), NULL },
+    { GIMP_GRADIENT_SQUARE, NC_("gradient-type", "Square"), NULL },
+    { GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (sym)"), NULL },
+    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asym)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, NC_("gradient-type", "Shaped (angular)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, NC_("gradient-type", "Shaped (spherical)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, NC_("gradient-type", "Shaped (dimpled)"), NULL },
+    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (cw)"), NULL },
+    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (ccw)"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -621,9 +621,9 @@ gimp_gradient_segment_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpGradientSegmentType", values);
+      type = g_enum_register_static ("GimpGradientType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "gradient-segment-type");
+      gimp_type_set_translation_context (type, "gradient-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -901,19 +901,21 @@ gimp_merge_type_get_type (void)
 }
 
 GType
-gimp_offset_type_get_type (void)
+gimp_message_handler_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", "background" },
-    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", "transparent" },
+    { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", "message-box" },
+    { GIMP_CONSOLE, "GIMP_CONSOLE", "console" },
+    { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", "error-console" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", NULL },
-    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", NULL },
+    { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", NULL },
+    { GIMP_CONSOLE, "GIMP_CONSOLE", NULL },
+    { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", NULL },
     { 0, NULL, NULL }
   };
 
@@ -921,9 +923,9 @@ gimp_offset_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpOffsetType", values);
+      type = g_enum_register_static ("GimpMessageHandlerType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "offset-type");
+      gimp_type_set_translation_context (type, "message-handler-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -931,21 +933,19 @@ gimp_offset_type_get_type (void)
 }
 
 GType
-gimp_orientation_type_get_type (void)
+gimp_offset_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ORIENTATION_HORIZONTAL, "GIMP_ORIENTATION_HORIZONTAL", "horizontal" },
-    { GIMP_ORIENTATION_VERTICAL, "GIMP_ORIENTATION_VERTICAL", "vertical" },
-    { GIMP_ORIENTATION_UNKNOWN, "GIMP_ORIENTATION_UNKNOWN", "unknown" },
+    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", "background" },
+    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", "transparent" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_ORIENTATION_HORIZONTAL, NC_("orientation-type", "Horizontal"), NULL },
-    { GIMP_ORIENTATION_VERTICAL, NC_("orientation-type", "Vertical"), NULL },
-    { GIMP_ORIENTATION_UNKNOWN, NC_("orientation-type", "Unknown"), NULL },
+    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", NULL },
+    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", NULL },
     { 0, NULL, NULL }
   };
 
@@ -953,9 +953,9 @@ gimp_orientation_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpOrientationType", values);
+      type = g_enum_register_static ("GimpOffsetType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "orientation-type");
+      gimp_type_set_translation_context (type, "offset-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -963,19 +963,21 @@ gimp_orientation_type_get_type (void)
 }
 
 GType
-gimp_paint_application_mode_get_type (void)
+gimp_orientation_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
-    { GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
+    { GIMP_ORIENTATION_HORIZONTAL, "GIMP_ORIENTATION_HORIZONTAL", "horizontal" },
+    { GIMP_ORIENTATION_VERTICAL, "GIMP_ORIENTATION_VERTICAL", "vertical" },
+    { GIMP_ORIENTATION_UNKNOWN, "GIMP_ORIENTATION_UNKNOWN", "unknown" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PAINT_CONSTANT, NC_("paint-application-mode", "Constant"), NULL },
-    { GIMP_PAINT_INCREMENTAL, NC_("paint-application-mode", "Incremental"), NULL },
+    { GIMP_ORIENTATION_HORIZONTAL, NC_("orientation-type", "Horizontal"), NULL },
+    { GIMP_ORIENTATION_VERTICAL, NC_("orientation-type", "Vertical"), NULL },
+    { GIMP_ORIENTATION_UNKNOWN, NC_("orientation-type", "Unknown"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -983,9 +985,9 @@ gimp_paint_application_mode_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPaintApplicationMode", values);
+      type = g_enum_register_static ("GimpOrientationType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "paint-application-mode");
+      gimp_type_set_translation_context (type, "orientation-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -993,39 +995,19 @@ gimp_paint_application_mode_get_type (void)
 }
 
 GType
-gimp_precision_get_type (void)
+gimp_paint_application_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PRECISION_U8_LINEAR, "GIMP_PRECISION_U8_LINEAR", "u8-linear" },
-    { GIMP_PRECISION_U8_GAMMA, "GIMP_PRECISION_U8_GAMMA", "u8-gamma" },
-    { GIMP_PRECISION_U16_LINEAR, "GIMP_PRECISION_U16_LINEAR", "u16-linear" },
-    { GIMP_PRECISION_U16_GAMMA, "GIMP_PRECISION_U16_GAMMA", "u16-gamma" },
-    { GIMP_PRECISION_U32_LINEAR, "GIMP_PRECISION_U32_LINEAR", "u32-linear" },
-    { GIMP_PRECISION_U32_GAMMA, "GIMP_PRECISION_U32_GAMMA", "u32-gamma" },
-    { GIMP_PRECISION_HALF_LINEAR, "GIMP_PRECISION_HALF_LINEAR", "half-linear" },
-    { GIMP_PRECISION_HALF_GAMMA, "GIMP_PRECISION_HALF_GAMMA", "half-gamma" },
-    { GIMP_PRECISION_FLOAT_LINEAR, "GIMP_PRECISION_FLOAT_LINEAR", "float-linear" },
-    { GIMP_PRECISION_FLOAT_GAMMA, "GIMP_PRECISION_FLOAT_GAMMA", "float-gamma" },
-    { GIMP_PRECISION_DOUBLE_LINEAR, "GIMP_PRECISION_DOUBLE_LINEAR", "double-linear" },
-    { GIMP_PRECISION_DOUBLE_GAMMA, "GIMP_PRECISION_DOUBLE_GAMMA", "double-gamma" },
+    { GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
+    { GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PRECISION_U8_LINEAR, NC_("precision", "8-bit linear integer"), NULL },
-    { GIMP_PRECISION_U8_GAMMA, NC_("precision", "8-bit gamma integer"), NULL },
-    { GIMP_PRECISION_U16_LINEAR, NC_("precision", "16-bit linear integer"), NULL },
-    { GIMP_PRECISION_U16_GAMMA, NC_("precision", "16-bit gamma integer"), NULL },
-    { GIMP_PRECISION_U32_LINEAR, NC_("precision", "32-bit linear integer"), NULL },
-    { GIMP_PRECISION_U32_GAMMA, NC_("precision", "32-bit gamma integer"), NULL },
-    { GIMP_PRECISION_HALF_LINEAR, NC_("precision", "16-bit linear floating point"), NULL },
-    { GIMP_PRECISION_HALF_GAMMA, NC_("precision", "16-bit gamma floating point"), NULL },
-    { GIMP_PRECISION_FLOAT_LINEAR, NC_("precision", "32-bit linear floating point"), NULL },
-    { GIMP_PRECISION_FLOAT_GAMMA, NC_("precision", "32-bit gamma floating point"), NULL },
-    { GIMP_PRECISION_DOUBLE_LINEAR, NC_("precision", "64-bit linear floating point"), NULL },
-    { GIMP_PRECISION_DOUBLE_GAMMA, NC_("precision", "64-bit gamma floating point"), NULL },
+    { GIMP_PAINT_CONSTANT, NC_("paint-application-mode", "Constant"), NULL },
+    { GIMP_PAINT_INCREMENTAL, NC_("paint-application-mode", "Incremental"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1033,9 +1015,9 @@ gimp_precision_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPrecision", values);
+      type = g_enum_register_static ("GimpPaintApplicationMode", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "precision");
+      gimp_type_set_translation_context (type, "paint-application-mode");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1043,23 +1025,61 @@ gimp_precision_get_type (void)
 }
 
 GType
-gimp_repeat_mode_get_type (void)
+gimp_pdb_arg_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
-    { GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
-    { GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
-    { GIMP_REPEAT_TRUNCATE, "GIMP_REPEAT_TRUNCATE", "truncate" },
+    { GIMP_PDB_INT32, "GIMP_PDB_INT32", "int32" },
+    { GIMP_PDB_INT16, "GIMP_PDB_INT16", "int16" },
+    { GIMP_PDB_INT8, "GIMP_PDB_INT8", "int8" },
+    { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", "float" },
+    { GIMP_PDB_STRING, "GIMP_PDB_STRING", "string" },
+    { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", "int32array" },
+    { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", "int16array" },
+    { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", "int8array" },
+    { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", "floatarray" },
+    { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", "stringarray" },
+    { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", "color" },
+    { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", "item" },
+    { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", "display" },
+    { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", "image" },
+    { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", "layer" },
+    { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", "channel" },
+    { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", "drawable" },
+    { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", "selection" },
+    { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", "colorarray" },
+    { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", "vectors" },
+    { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", "parasite" },
+    { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", "status" },
+    { GIMP_PDB_END, "GIMP_PDB_END", "end" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_REPEAT_NONE, NC_("repeat-mode", "None (extend)"), NULL },
-    { GIMP_REPEAT_SAWTOOTH, NC_("repeat-mode", "Sawtooth wave"), NULL },
-    { GIMP_REPEAT_TRIANGULAR, NC_("repeat-mode", "Triangular wave"), NULL },
-    { GIMP_REPEAT_TRUNCATE, NC_("repeat-mode", "Truncate"), NULL },
+    { GIMP_PDB_INT32, "GIMP_PDB_INT32", NULL },
+    { GIMP_PDB_INT16, "GIMP_PDB_INT16", NULL },
+    { GIMP_PDB_INT8, "GIMP_PDB_INT8", NULL },
+    { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", NULL },
+    { GIMP_PDB_STRING, "GIMP_PDB_STRING", NULL },
+    { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", NULL },
+    { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", NULL },
+    { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", NULL },
+    { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", NULL },
+    { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", NULL },
+    { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", NULL },
+    { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", NULL },
+    { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", NULL },
+    { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", NULL },
+    { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", NULL },
+    { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", NULL },
+    { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", NULL },
+    { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", NULL },
+    { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", NULL },
+    { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", NULL },
+    { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", NULL },
+    { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", NULL },
+    { GIMP_PDB_END, "GIMP_PDB_END", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1067,9 +1087,9 @@ gimp_repeat_mode_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpRepeatMode", values);
+      type = g_enum_register_static ("GimpPDBArgType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "repeat-mode");
+      gimp_type_set_translation_context (type, "pdb-arg-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1077,21 +1097,19 @@ gimp_repeat_mode_get_type (void)
 }
 
 GType
-gimp_rotation_type_get_type (void)
+gimp_pdb_error_handler_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ROTATE_90, "GIMP_ROTATE_90", "90" },
-    { GIMP_ROTATE_180, "GIMP_ROTATE_180", "180" },
-    { GIMP_ROTATE_270, "GIMP_ROTATE_270", "270" },
+    { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", "internal" },
+    { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", "plugin" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_ROTATE_90, "GIMP_ROTATE_90", NULL },
-    { GIMP_ROTATE_180, "GIMP_ROTATE_180", NULL },
-    { GIMP_ROTATE_270, "GIMP_ROTATE_270", NULL },
+    { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", NULL },
+    { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1099,9 +1117,9 @@ gimp_rotation_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpRotationType", values);
+      type = g_enum_register_static ("GimpPDBErrorHandler", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "rotation-type");
+      gimp_type_set_translation_context (type, "pdb-error-handler");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1109,21 +1127,23 @@ gimp_rotation_type_get_type (void)
 }
 
 GType
-gimp_run_mode_get_type (void)
+gimp_pdb_proc_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_RUN_INTERACTIVE, "GIMP_RUN_INTERACTIVE", "interactive" },
-    { GIMP_RUN_NONINTERACTIVE, "GIMP_RUN_NONINTERACTIVE", "noninteractive" },
-    { GIMP_RUN_WITH_LAST_VALS, "GIMP_RUN_WITH_LAST_VALS", "with-last-vals" },
+    { GIMP_INTERNAL, "GIMP_INTERNAL", "internal" },
+    { GIMP_PLUGIN, "GIMP_PLUGIN", "plugin" },
+    { GIMP_EXTENSION, "GIMP_EXTENSION", "extension" },
+    { GIMP_TEMPORARY, "GIMP_TEMPORARY", "temporary" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_RUN_INTERACTIVE, NC_("run-mode", "Run interactively"), NULL },
-    { GIMP_RUN_NONINTERACTIVE, NC_("run-mode", "Run non-interactively"), NULL },
-    { GIMP_RUN_WITH_LAST_VALS, NC_("run-mode", "Run with last used values"), NULL },
+    { GIMP_INTERNAL, NC_("pdb-proc-type", "Internal GIMP procedure"), NULL },
+    { GIMP_PLUGIN, NC_("pdb-proc-type", "GIMP Plug-In"), NULL },
+    { GIMP_EXTENSION, NC_("pdb-proc-type", "GIMP Extension"), NULL },
+    { GIMP_TEMPORARY, NC_("pdb-proc-type", "Temporary Procedure"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1131,9 +1151,9 @@ gimp_run_mode_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpRunMode", values);
+      type = g_enum_register_static ("GimpPDBProcType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "run-mode");
+      gimp_type_set_translation_context (type, "pdb-proc-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1141,29 +1161,25 @@ gimp_run_mode_get_type (void)
 }
 
 GType
-gimp_select_criterion_get_type (void)
+gimp_pdb_status_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_SELECT_CRITERION_COMPOSITE, "GIMP_SELECT_CRITERION_COMPOSITE", "composite" },
-    { GIMP_SELECT_CRITERION_R, "GIMP_SELECT_CRITERION_R", "r" },
-    { GIMP_SELECT_CRITERION_G, "GIMP_SELECT_CRITERION_G", "g" },
-    { GIMP_SELECT_CRITERION_B, "GIMP_SELECT_CRITERION_B", "b" },
-    { GIMP_SELECT_CRITERION_H, "GIMP_SELECT_CRITERION_H", "h" },
-    { GIMP_SELECT_CRITERION_S, "GIMP_SELECT_CRITERION_S", "s" },
-    { GIMP_SELECT_CRITERION_V, "GIMP_SELECT_CRITERION_V", "v" },
+    { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", "execution-error" },
+    { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", "calling-error" },
+    { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", "pass-through" },
+    { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", "success" },
+    { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", "cancel" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_SELECT_CRITERION_COMPOSITE, NC_("select-criterion", "Composite"), NULL },
-    { GIMP_SELECT_CRITERION_R, NC_("select-criterion", "Red"), NULL },
-    { GIMP_SELECT_CRITERION_G, NC_("select-criterion", "Green"), NULL },
-    { GIMP_SELECT_CRITERION_B, NC_("select-criterion", "Blue"), NULL },
-    { GIMP_SELECT_CRITERION_H, NC_("select-criterion", "Hue"), NULL },
-    { GIMP_SELECT_CRITERION_S, NC_("select-criterion", "Saturation"), NULL },
-    { GIMP_SELECT_CRITERION_V, NC_("select-criterion", "Value"), NULL },
+    { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", NULL },
+    { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", NULL },
+    { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", NULL },
+    { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", NULL },
+    { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1171,9 +1187,9 @@ gimp_select_criterion_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpSelectCriterion", values);
+      type = g_enum_register_static ("GimpPDBStatusType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "select-criterion");
+      gimp_type_set_translation_context (type, "pdb-status-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1181,19 +1197,39 @@ gimp_select_criterion_get_type (void)
 }
 
 GType
-gimp_size_type_get_type (void)
+gimp_precision_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PIXELS, "GIMP_PIXELS", "pixels" },
-    { GIMP_POINTS, "GIMP_POINTS", "points" },
+    { GIMP_PRECISION_U8_LINEAR, "GIMP_PRECISION_U8_LINEAR", "u8-linear" },
+    { GIMP_PRECISION_U8_GAMMA, "GIMP_PRECISION_U8_GAMMA", "u8-gamma" },
+    { GIMP_PRECISION_U16_LINEAR, "GIMP_PRECISION_U16_LINEAR", "u16-linear" },
+    { GIMP_PRECISION_U16_GAMMA, "GIMP_PRECISION_U16_GAMMA", "u16-gamma" },
+    { GIMP_PRECISION_U32_LINEAR, "GIMP_PRECISION_U32_LINEAR", "u32-linear" },
+    { GIMP_PRECISION_U32_GAMMA, "GIMP_PRECISION_U32_GAMMA", "u32-gamma" },
+    { GIMP_PRECISION_HALF_LINEAR, "GIMP_PRECISION_HALF_LINEAR", "half-linear" },
+    { GIMP_PRECISION_HALF_GAMMA, "GIMP_PRECISION_HALF_GAMMA", "half-gamma" },
+    { GIMP_PRECISION_FLOAT_LINEAR, "GIMP_PRECISION_FLOAT_LINEAR", "float-linear" },
+    { GIMP_PRECISION_FLOAT_GAMMA, "GIMP_PRECISION_FLOAT_GAMMA", "float-gamma" },
+    { GIMP_PRECISION_DOUBLE_LINEAR, "GIMP_PRECISION_DOUBLE_LINEAR", "double-linear" },
+    { GIMP_PRECISION_DOUBLE_GAMMA, "GIMP_PRECISION_DOUBLE_GAMMA", "double-gamma" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PIXELS, NC_("size-type", "Pixels"), NULL },
-    { GIMP_POINTS, NC_("size-type", "Points"), NULL },
+    { GIMP_PRECISION_U8_LINEAR, NC_("precision", "8-bit linear integer"), NULL },
+    { GIMP_PRECISION_U8_GAMMA, NC_("precision", "8-bit gamma integer"), NULL },
+    { GIMP_PRECISION_U16_LINEAR, NC_("precision", "16-bit linear integer"), NULL },
+    { GIMP_PRECISION_U16_GAMMA, NC_("precision", "16-bit gamma integer"), NULL },
+    { GIMP_PRECISION_U32_LINEAR, NC_("precision", "32-bit linear integer"), NULL },
+    { GIMP_PRECISION_U32_GAMMA, NC_("precision", "32-bit gamma integer"), NULL },
+    { GIMP_PRECISION_HALF_LINEAR, NC_("precision", "16-bit linear floating point"), NULL },
+    { GIMP_PRECISION_HALF_GAMMA, NC_("precision", "16-bit gamma floating point"), NULL },
+    { GIMP_PRECISION_FLOAT_LINEAR, NC_("precision", "32-bit linear floating point"), NULL },
+    { GIMP_PRECISION_FLOAT_GAMMA, NC_("precision", "32-bit gamma floating point"), NULL },
+    { GIMP_PRECISION_DOUBLE_LINEAR, NC_("precision", "64-bit linear floating point"), NULL },
+    { GIMP_PRECISION_DOUBLE_GAMMA, NC_("precision", "64-bit gamma floating point"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1201,9 +1237,9 @@ gimp_size_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpSizeType", values);
+      type = g_enum_register_static ("GimpPrecision", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "size-type");
+      gimp_type_set_translation_context (type, "precision");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1211,21 +1247,27 @@ gimp_size_type_get_type (void)
 }
 
 GType
-gimp_transfer_mode_get_type (void)
+gimp_progress_command_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFER_SHADOWS, "GIMP_TRANSFER_SHADOWS", "shadows" },
-    { GIMP_TRANSFER_MIDTONES, "GIMP_TRANSFER_MIDTONES", "midtones" },
-    { GIMP_TRANSFER_HIGHLIGHTS, "GIMP_TRANSFER_HIGHLIGHTS", "highlights" },
+    { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", "start" },
+    { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", "end" },
+    { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" },
+    { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" },
+    { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" },
+    { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
-    { GIMP_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
-    { GIMP_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
+    { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", NULL },
+    { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", NULL },
+    { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL },
+    { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL },
+    { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL },
+    { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1233,9 +1275,9 @@ gimp_transfer_mode_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTransferMode", values);
+      type = g_enum_register_static ("GimpProgressCommand", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "transfer-mode");
+      gimp_type_set_translation_context (type, "progress-command");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1243,19 +1285,23 @@ gimp_transfer_mode_get_type (void)
 }
 
 GType
-gimp_transform_direction_get_type (void)
+gimp_repeat_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
-    { GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
+    { GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
+    { GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
+    { GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
+    { GIMP_REPEAT_TRUNCATE, "GIMP_REPEAT_TRUNCATE", "truncate" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TRANSFORM_FORWARD, NC_("transform-direction", "Normal (Forward)"), NULL },
-    { GIMP_TRANSFORM_BACKWARD, NC_("transform-direction", "Corrective (Backward)"), NULL },
+    { GIMP_REPEAT_NONE, NC_("repeat-mode", "None (extend)"), NULL },
+    { GIMP_REPEAT_SAWTOOTH, NC_("repeat-mode", "Sawtooth wave"), NULL },
+    { GIMP_REPEAT_TRIANGULAR, NC_("repeat-mode", "Triangular wave"), NULL },
+    { GIMP_REPEAT_TRUNCATE, NC_("repeat-mode", "Truncate"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1263,9 +1309,9 @@ gimp_transform_direction_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTransformDirection", values);
+      type = g_enum_register_static ("GimpRepeatMode", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "transform-direction");
+      gimp_type_set_translation_context (type, "repeat-mode");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1273,23 +1319,21 @@ gimp_transform_direction_get_type (void)
 }
 
 GType
-gimp_transform_resize_get_type (void)
+gimp_rotation_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_RESIZE_ADJUST, "GIMP_TRANSFORM_RESIZE_ADJUST", "adjust" },
-    { GIMP_TRANSFORM_RESIZE_CLIP, "GIMP_TRANSFORM_RESIZE_CLIP", "clip" },
-    { GIMP_TRANSFORM_RESIZE_CROP, "GIMP_TRANSFORM_RESIZE_CROP", "crop" },
-    { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, "GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT", "crop-with-aspect" },
+    { GIMP_ROTATE_90, "GIMP_ROTATE_90", "90" },
+    { GIMP_ROTATE_180, "GIMP_ROTATE_180", "180" },
+    { GIMP_ROTATE_270, "GIMP_ROTATE_270", "270" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TRANSFORM_RESIZE_ADJUST, NC_("transform-resize", "Adjust"), NULL },
-    { GIMP_TRANSFORM_RESIZE_CLIP, NC_("transform-resize", "Clip"), NULL },
-    { GIMP_TRANSFORM_RESIZE_CROP, NC_("transform-resize", "Crop to result"), NULL },
-    { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, NC_("transform-resize", "Crop with aspect"), NULL },
+    { GIMP_ROTATE_90, "GIMP_ROTATE_90", NULL },
+    { GIMP_ROTATE_180, "GIMP_ROTATE_180", NULL },
+    { GIMP_ROTATE_270, "GIMP_ROTATE_270", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1297,9 +1341,9 @@ gimp_transform_resize_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTransformResize", values);
+      type = g_enum_register_static ("GimpRotationType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "transform-resize");
+      gimp_type_set_translation_context (type, "rotation-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1307,61 +1351,21 @@ gimp_transform_resize_get_type (void)
 }
 
 GType
-gimp_pdb_arg_type_get_type (void)
+gimp_run_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PDB_INT32, "GIMP_PDB_INT32", "int32" },
-    { GIMP_PDB_INT16, "GIMP_PDB_INT16", "int16" },
-    { GIMP_PDB_INT8, "GIMP_PDB_INT8", "int8" },
-    { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", "float" },
-    { GIMP_PDB_STRING, "GIMP_PDB_STRING", "string" },
-    { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", "int32array" },
-    { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", "int16array" },
-    { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", "int8array" },
-    { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", "floatarray" },
-    { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", "stringarray" },
-    { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", "color" },
-    { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", "item" },
-    { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", "display" },
-    { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", "image" },
-    { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", "layer" },
-    { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", "channel" },
-    { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", "drawable" },
-    { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", "selection" },
-    { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", "colorarray" },
-    { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", "vectors" },
-    { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", "parasite" },
-    { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", "status" },
-    { GIMP_PDB_END, "GIMP_PDB_END", "end" },
+    { GIMP_RUN_INTERACTIVE, "GIMP_RUN_INTERACTIVE", "interactive" },
+    { GIMP_RUN_NONINTERACTIVE, "GIMP_RUN_NONINTERACTIVE", "noninteractive" },
+    { GIMP_RUN_WITH_LAST_VALS, "GIMP_RUN_WITH_LAST_VALS", "with-last-vals" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PDB_INT32, "GIMP_PDB_INT32", NULL },
-    { GIMP_PDB_INT16, "GIMP_PDB_INT16", NULL },
-    { GIMP_PDB_INT8, "GIMP_PDB_INT8", NULL },
-    { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", NULL },
-    { GIMP_PDB_STRING, "GIMP_PDB_STRING", NULL },
-    { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", NULL },
-    { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", NULL },
-    { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", NULL },
-    { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", NULL },
-    { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", NULL },
-    { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", NULL },
-    { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", NULL },
-    { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", NULL },
-    { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", NULL },
-    { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", NULL },
-    { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", NULL },
-    { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", NULL },
-    { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", NULL },
-    { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", NULL },
-    { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", NULL },
-    { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", NULL },
-    { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", NULL },
-    { GIMP_PDB_END, "GIMP_PDB_END", NULL },
+    { GIMP_RUN_INTERACTIVE, NC_("run-mode", "Run interactively"), NULL },
+    { GIMP_RUN_NONINTERACTIVE, NC_("run-mode", "Run non-interactively"), NULL },
+    { GIMP_RUN_WITH_LAST_VALS, NC_("run-mode", "Run with last used values"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1369,9 +1373,9 @@ gimp_pdb_arg_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPDBArgType", values);
+      type = g_enum_register_static ("GimpRunMode", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "pdb-arg-type");
+      gimp_type_set_translation_context (type, "run-mode");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1379,19 +1383,29 @@ gimp_pdb_arg_type_get_type (void)
 }
 
 GType
-gimp_pdb_error_handler_get_type (void)
+gimp_select_criterion_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", "internal" },
-    { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", "plugin" },
+    { GIMP_SELECT_CRITERION_COMPOSITE, "GIMP_SELECT_CRITERION_COMPOSITE", "composite" },
+    { GIMP_SELECT_CRITERION_R, "GIMP_SELECT_CRITERION_R", "r" },
+    { GIMP_SELECT_CRITERION_G, "GIMP_SELECT_CRITERION_G", "g" },
+    { GIMP_SELECT_CRITERION_B, "GIMP_SELECT_CRITERION_B", "b" },
+    { GIMP_SELECT_CRITERION_H, "GIMP_SELECT_CRITERION_H", "h" },
+    { GIMP_SELECT_CRITERION_S, "GIMP_SELECT_CRITERION_S", "s" },
+    { GIMP_SELECT_CRITERION_V, "GIMP_SELECT_CRITERION_V", "v" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", NULL },
-    { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", NULL },
+    { GIMP_SELECT_CRITERION_COMPOSITE, NC_("select-criterion", "Composite"), NULL },
+    { GIMP_SELECT_CRITERION_R, NC_("select-criterion", "Red"), NULL },
+    { GIMP_SELECT_CRITERION_G, NC_("select-criterion", "Green"), NULL },
+    { GIMP_SELECT_CRITERION_B, NC_("select-criterion", "Blue"), NULL },
+    { GIMP_SELECT_CRITERION_H, NC_("select-criterion", "Hue"), NULL },
+    { GIMP_SELECT_CRITERION_S, NC_("select-criterion", "Saturation"), NULL },
+    { GIMP_SELECT_CRITERION_V, NC_("select-criterion", "Value"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1399,9 +1413,9 @@ gimp_pdb_error_handler_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPDBErrorHandler", values);
+      type = g_enum_register_static ("GimpSelectCriterion", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "pdb-error-handler");
+      gimp_type_set_translation_context (type, "select-criterion");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1409,23 +1423,19 @@ gimp_pdb_error_handler_get_type (void)
 }
 
 GType
-gimp_pdb_proc_type_get_type (void)
+gimp_size_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_INTERNAL, "GIMP_INTERNAL", "internal" },
-    { GIMP_PLUGIN, "GIMP_PLUGIN", "plugin" },
-    { GIMP_EXTENSION, "GIMP_EXTENSION", "extension" },
-    { GIMP_TEMPORARY, "GIMP_TEMPORARY", "temporary" },
+    { GIMP_PIXELS, "GIMP_PIXELS", "pixels" },
+    { GIMP_POINTS, "GIMP_POINTS", "points" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_INTERNAL, NC_("pdb-proc-type", "Internal GIMP procedure"), NULL },
-    { GIMP_PLUGIN, NC_("pdb-proc-type", "GIMP Plug-In"), NULL },
-    { GIMP_EXTENSION, NC_("pdb-proc-type", "GIMP Extension"), NULL },
-    { GIMP_TEMPORARY, NC_("pdb-proc-type", "Temporary Procedure"), NULL },
+    { GIMP_PIXELS, NC_("size-type", "Pixels"), NULL },
+    { GIMP_POINTS, NC_("size-type", "Points"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1433,9 +1443,9 @@ gimp_pdb_proc_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPDBProcType", values);
+      type = g_enum_register_static ("GimpSizeType", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "pdb-proc-type");
+      gimp_type_set_translation_context (type, "size-type");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1443,25 +1453,21 @@ gimp_pdb_proc_type_get_type (void)
 }
 
 GType
-gimp_pdb_status_type_get_type (void)
+gimp_stack_trace_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", "execution-error" },
-    { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", "calling-error" },
-    { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", "pass-through" },
-    { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", "success" },
-    { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", "cancel" },
+    { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", "never" },
+    { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", "query" },
+    { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", "always" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", NULL },
-    { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", NULL },
-    { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", NULL },
-    { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", NULL },
-    { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", NULL },
+    { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", NULL },
+    { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", NULL },
+    { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", NULL },
     { 0, NULL, NULL }
   };
 
@@ -1469,9 +1475,9 @@ gimp_pdb_status_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpPDBStatusType", values);
+      type = g_enum_register_static ("GimpStackTraceMode", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "pdb-status-type");
+      gimp_type_set_translation_context (type, "stack-trace-mode");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1479,21 +1485,19 @@ gimp_pdb_status_type_get_type (void)
 }
 
 GType
-gimp_message_handler_type_get_type (void)
+gimp_text_direction_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", "message-box" },
-    { GIMP_CONSOLE, "GIMP_CONSOLE", "console" },
-    { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", "error-console" },
+    { GIMP_TEXT_DIRECTION_LTR, "GIMP_TEXT_DIRECTION_LTR", "ltr" },
+    { GIMP_TEXT_DIRECTION_RTL, "GIMP_TEXT_DIRECTION_RTL", "rtl" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", NULL },
-    { GIMP_CONSOLE, "GIMP_CONSOLE", NULL },
-    { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", NULL },
+    { GIMP_TEXT_DIRECTION_LTR, NC_("text-direction", "From left to right"), NULL },
+    { GIMP_TEXT_DIRECTION_RTL, NC_("text-direction", "From right to left"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1501,9 +1505,9 @@ gimp_message_handler_type_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpMessageHandlerType", values);
+      type = g_enum_register_static ("GimpTextDirection", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "message-handler-type");
+      gimp_type_set_translation_context (type, "text-direction");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1511,21 +1515,23 @@ gimp_message_handler_type_get_type (void)
 }
 
 GType
-gimp_stack_trace_mode_get_type (void)
+gimp_text_hint_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", "never" },
-    { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", "query" },
-    { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", "always" },
+    { GIMP_TEXT_HINT_STYLE_NONE, "GIMP_TEXT_HINT_STYLE_NONE", "none" },
+    { GIMP_TEXT_HINT_STYLE_SLIGHT, "GIMP_TEXT_HINT_STYLE_SLIGHT", "slight" },
+    { GIMP_TEXT_HINT_STYLE_MEDIUM, "GIMP_TEXT_HINT_STYLE_MEDIUM", "medium" },
+    { GIMP_TEXT_HINT_STYLE_FULL, "GIMP_TEXT_HINT_STYLE_FULL", "full" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", NULL },
-    { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", NULL },
-    { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", NULL },
+    { GIMP_TEXT_HINT_STYLE_NONE, NC_("text-hint-style", "None"), NULL },
+    { GIMP_TEXT_HINT_STYLE_SLIGHT, NC_("text-hint-style", "Slight"), NULL },
+    { GIMP_TEXT_HINT_STYLE_MEDIUM, NC_("text-hint-style", "Medium"), NULL },
+    { GIMP_TEXT_HINT_STYLE_FULL, NC_("text-hint-style", "Full"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1533,9 +1539,9 @@ gimp_stack_trace_mode_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpStackTraceMode", values);
+      type = g_enum_register_static ("GimpTextHintStyle", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "stack-trace-mode");
+      gimp_type_set_translation_context (type, "text-hint-style");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1543,27 +1549,23 @@ gimp_stack_trace_mode_get_type (void)
 }
 
 GType
-gimp_progress_command_get_type (void)
+gimp_text_justification_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", "start" },
-    { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", "end" },
-    { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" },
-    { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" },
-    { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" },
-    { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
+    { GIMP_TEXT_JUSTIFY_LEFT, "GIMP_TEXT_JUSTIFY_LEFT", "left" },
+    { GIMP_TEXT_JUSTIFY_RIGHT, "GIMP_TEXT_JUSTIFY_RIGHT", "right" },
+    { GIMP_TEXT_JUSTIFY_CENTER, "GIMP_TEXT_JUSTIFY_CENTER", "center" },
+    { GIMP_TEXT_JUSTIFY_FILL, "GIMP_TEXT_JUSTIFY_FILL", "fill" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", NULL },
-    { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", NULL },
-    { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL },
-    { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL },
-    { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL },
-    { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", NULL },
+    { GIMP_TEXT_JUSTIFY_LEFT, NC_("text-justification", "Left justified"), NULL },
+    { GIMP_TEXT_JUSTIFY_RIGHT, NC_("text-justification", "Right justified"), NULL },
+    { GIMP_TEXT_JUSTIFY_CENTER, NC_("text-justification", "Centered"), NULL },
+    { GIMP_TEXT_JUSTIFY_FILL, NC_("text-justification", "Filled"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1571,9 +1573,9 @@ gimp_progress_command_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpProgressCommand", values);
+      type = g_enum_register_static ("GimpTextJustification", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "progress-command");
+      gimp_type_set_translation_context (type, "text-justification");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1581,19 +1583,21 @@ gimp_progress_command_get_type (void)
 }
 
 GType
-gimp_text_direction_get_type (void)
+gimp_transfer_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TEXT_DIRECTION_LTR, "GIMP_TEXT_DIRECTION_LTR", "ltr" },
-    { GIMP_TEXT_DIRECTION_RTL, "GIMP_TEXT_DIRECTION_RTL", "rtl" },
+    { GIMP_TRANSFER_SHADOWS, "GIMP_TRANSFER_SHADOWS", "shadows" },
+    { GIMP_TRANSFER_MIDTONES, "GIMP_TRANSFER_MIDTONES", "midtones" },
+    { GIMP_TRANSFER_HIGHLIGHTS, "GIMP_TRANSFER_HIGHLIGHTS", "highlights" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TEXT_DIRECTION_LTR, NC_("text-direction", "From left to right"), NULL },
-    { GIMP_TEXT_DIRECTION_RTL, NC_("text-direction", "From right to left"), NULL },
+    { GIMP_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
+    { GIMP_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
+    { GIMP_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1601,9 +1605,9 @@ gimp_text_direction_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTextDirection", values);
+      type = g_enum_register_static ("GimpTransferMode", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "text-direction");
+      gimp_type_set_translation_context (type, "transfer-mode");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1611,23 +1615,19 @@ gimp_text_direction_get_type (void)
 }
 
 GType
-gimp_text_hint_style_get_type (void)
+gimp_transform_direction_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TEXT_HINT_STYLE_NONE, "GIMP_TEXT_HINT_STYLE_NONE", "none" },
-    { GIMP_TEXT_HINT_STYLE_SLIGHT, "GIMP_TEXT_HINT_STYLE_SLIGHT", "slight" },
-    { GIMP_TEXT_HINT_STYLE_MEDIUM, "GIMP_TEXT_HINT_STYLE_MEDIUM", "medium" },
-    { GIMP_TEXT_HINT_STYLE_FULL, "GIMP_TEXT_HINT_STYLE_FULL", "full" },
+    { GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
+    { GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TEXT_HINT_STYLE_NONE, NC_("text-hint-style", "None"), NULL },
-    { GIMP_TEXT_HINT_STYLE_SLIGHT, NC_("text-hint-style", "Slight"), NULL },
-    { GIMP_TEXT_HINT_STYLE_MEDIUM, NC_("text-hint-style", "Medium"), NULL },
-    { GIMP_TEXT_HINT_STYLE_FULL, NC_("text-hint-style", "Full"), NULL },
+    { GIMP_TRANSFORM_FORWARD, NC_("transform-direction", "Normal (Forward)"), NULL },
+    { GIMP_TRANSFORM_BACKWARD, NC_("transform-direction", "Corrective (Backward)"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1635,9 +1635,9 @@ gimp_text_hint_style_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTextHintStyle", values);
+      type = g_enum_register_static ("GimpTransformDirection", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "text-hint-style");
+      gimp_type_set_translation_context (type, "transform-direction");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
@@ -1645,23 +1645,23 @@ gimp_text_hint_style_get_type (void)
 }
 
 GType
-gimp_text_justification_get_type (void)
+gimp_transform_resize_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TEXT_JUSTIFY_LEFT, "GIMP_TEXT_JUSTIFY_LEFT", "left" },
-    { GIMP_TEXT_JUSTIFY_RIGHT, "GIMP_TEXT_JUSTIFY_RIGHT", "right" },
-    { GIMP_TEXT_JUSTIFY_CENTER, "GIMP_TEXT_JUSTIFY_CENTER", "center" },
-    { GIMP_TEXT_JUSTIFY_FILL, "GIMP_TEXT_JUSTIFY_FILL", "fill" },
+    { GIMP_TRANSFORM_RESIZE_ADJUST, "GIMP_TRANSFORM_RESIZE_ADJUST", "adjust" },
+    { GIMP_TRANSFORM_RESIZE_CLIP, "GIMP_TRANSFORM_RESIZE_CLIP", "clip" },
+    { GIMP_TRANSFORM_RESIZE_CROP, "GIMP_TRANSFORM_RESIZE_CROP", "crop" },
+    { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, "GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT", "crop-with-aspect" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_TEXT_JUSTIFY_LEFT, NC_("text-justification", "Left justified"), NULL },
-    { GIMP_TEXT_JUSTIFY_RIGHT, NC_("text-justification", "Right justified"), NULL },
-    { GIMP_TEXT_JUSTIFY_CENTER, NC_("text-justification", "Centered"), NULL },
-    { GIMP_TEXT_JUSTIFY_FILL, NC_("text-justification", "Filled"), NULL },
+    { GIMP_TRANSFORM_RESIZE_ADJUST, NC_("transform-resize", "Adjust"), NULL },
+    { GIMP_TRANSFORM_RESIZE_CLIP, NC_("transform-resize", "Clip"), NULL },
+    { GIMP_TRANSFORM_RESIZE_CROP, NC_("transform-resize", "Crop to result"), NULL },
+    { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, NC_("transform-resize", "Crop with aspect"), NULL },
     { 0, NULL, NULL }
   };
 
@@ -1669,9 +1669,9 @@ gimp_text_justification_get_type (void)
 
   if (G_UNLIKELY (! type))
     {
-      type = g_enum_register_static ("GimpTextJustification", values);
+      type = g_enum_register_static ("GimpTransformResize", values);
       gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-      gimp_type_set_translation_context (type, "text-justification");
+      gimp_type_set_translation_context (type, "transform-resize");
       gimp_enum_set_value_descriptions (type, descs);
     }
 
diff --git a/libgimpbase/gimpbaseenums.h b/libgimpbase/gimpbaseenums.h
index 815c427..39111cc 100644
--- a/libgimpbase/gimpbaseenums.h
+++ b/libgimpbase/gimpbaseenums.h
@@ -165,6 +165,22 @@ typedef enum  /*< pdb-skip >*/
 } GimpCheckType;
 
 
+#define GIMP_TYPE_CLONE_TYPE (gimp_clone_type_get_type ())
+
+GType gimp_clone_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_CLONE_IMAGE,    /*< nick=image-clone,   desc="Image"   >*/
+  GIMP_CLONE_PATTERN,  /*< nick=pattern-clone, desc="Pattern" >*/
+
+#ifndef GIMP_DISABLE_DEPRECATED
+  GIMP_IMAGE_CLONE   = GIMP_CLONE_IMAGE,  /*< skip, pdb-skip >*/
+  GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN /*< skip, pdb-skip >*/
+#endif /* GIMP_DISABLE_DEPRECATED */
+} GimpCloneType;
+
+
 #define GIMP_TYPE_COMPONENT_TYPE (gimp_component_type_get_type ())
 
 GType gimp_component_type_get_type (void) G_GNUC_CONST;
@@ -196,22 +212,6 @@ typedef enum
 } GimpConvolveType;
 
 
-#define GIMP_TYPE_CLONE_TYPE (gimp_clone_type_get_type ())
-
-GType gimp_clone_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_CLONE_IMAGE,    /*< nick=image-clone,   desc="Image"   >*/
-  GIMP_CLONE_PATTERN,  /*< nick=pattern-clone, desc="Pattern" >*/
-
-#ifndef GIMP_DISABLE_DEPRECATED
-  GIMP_IMAGE_CLONE   = GIMP_CLONE_IMAGE,  /*< skip, pdb-skip >*/
-  GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN /*< skip, pdb-skip >*/
-#endif /* GIMP_DISABLE_DEPRECATED */
-} GimpCloneType;
-
-
 #define GIMP_TYPE_DESATURATE_MODE (gimp_desaturate_mode_get_type ())
 
 GType gimp_desaturate_mode_get_type (void) G_GNUC_CONST;
@@ -265,26 +265,6 @@ typedef enum
 } GimpForegroundExtractMode;
 
 
-#define GIMP_TYPE_GRADIENT_TYPE (gimp_gradient_type_get_type ())
-
-GType gimp_gradient_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_GRADIENT_LINEAR,                /*< desc="Linear"            >*/
-  GIMP_GRADIENT_BILINEAR,              /*< desc="Bi-linear"         >*/
-  GIMP_GRADIENT_RADIAL,                /*< desc="Radial"            >*/
-  GIMP_GRADIENT_SQUARE,                /*< desc="Square"            >*/
-  GIMP_GRADIENT_CONICAL_SYMMETRIC,     /*< desc="Conical (sym)"     >*/
-  GIMP_GRADIENT_CONICAL_ASYMMETRIC,    /*< desc="Conical (asym)"    >*/
-  GIMP_GRADIENT_SHAPEBURST_ANGULAR,    /*< desc="Shaped (angular)"  >*/
-  GIMP_GRADIENT_SHAPEBURST_SPHERICAL,  /*< desc="Shaped (spherical)">*/
-  GIMP_GRADIENT_SHAPEBURST_DIMPLED,    /*< desc="Shaped (dimpled)"  >*/
-  GIMP_GRADIENT_SPIRAL_CLOCKWISE,      /*< desc="Spiral (cw)"       >*/
-  GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE   /*< desc="Spiral (ccw)"      >*/
-} GimpGradientType;
-
-
 #define GIMP_TYPE_GRADIENT_SEGMENT_COLOR (gimp_gradient_segment_color_get_type ())
 
 GType gimp_gradient_segment_color_get_type (void) G_GNUC_CONST;
@@ -311,6 +291,26 @@ typedef enum
 } GimpGradientSegmentType;
 
 
+#define GIMP_TYPE_GRADIENT_TYPE (gimp_gradient_type_get_type ())
+
+GType gimp_gradient_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_GRADIENT_LINEAR,                /*< desc="Linear"            >*/
+  GIMP_GRADIENT_BILINEAR,              /*< desc="Bi-linear"         >*/
+  GIMP_GRADIENT_RADIAL,                /*< desc="Radial"            >*/
+  GIMP_GRADIENT_SQUARE,                /*< desc="Square"            >*/
+  GIMP_GRADIENT_CONICAL_SYMMETRIC,     /*< desc="Conical (sym)"     >*/
+  GIMP_GRADIENT_CONICAL_ASYMMETRIC,    /*< desc="Conical (asym)"    >*/
+  GIMP_GRADIENT_SHAPEBURST_ANGULAR,    /*< desc="Shaped (angular)"  >*/
+  GIMP_GRADIENT_SHAPEBURST_SPHERICAL,  /*< desc="Shaped (spherical)">*/
+  GIMP_GRADIENT_SHAPEBURST_DIMPLED,    /*< desc="Shaped (dimpled)"  >*/
+  GIMP_GRADIENT_SPIRAL_CLOCKWISE,      /*< desc="Spiral (cw)"       >*/
+  GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE   /*< desc="Spiral (ccw)"      >*/
+} GimpGradientType;
+
+
 #define GIMP_TYPE_GRID_STYLE (gimp_grid_style_get_type ())
 
 GType gimp_grid_style_get_type (void) G_GNUC_CONST;
@@ -422,6 +422,18 @@ typedef enum
 } GimpMergeType;
 
 
+#define GIMP_TYPE_MESSAGE_HANDLER_TYPE (gimp_message_handler_type_get_type ())
+
+GType gimp_message_handler_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_MESSAGE_BOX,
+  GIMP_CONSOLE,
+  GIMP_ERROR_CONSOLE
+} GimpMessageHandlerType;
+
+
 #define GIMP_TYPE_OFFSET_TYPE (gimp_offset_type_get_type ())
 
 GType gimp_offset_type_get_type (void) G_GNUC_CONST;
@@ -456,6 +468,82 @@ typedef enum
 } GimpPaintApplicationMode;
 
 
+#define GIMP_TYPE_PDB_ARG_TYPE (gimp_pdb_arg_type_get_type ())
+
+GType gimp_pdb_arg_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_PDB_INT32,
+  GIMP_PDB_INT16,
+  GIMP_PDB_INT8,
+  GIMP_PDB_FLOAT,
+  GIMP_PDB_STRING,
+  GIMP_PDB_INT32ARRAY,
+  GIMP_PDB_INT16ARRAY,
+  GIMP_PDB_INT8ARRAY,
+  GIMP_PDB_FLOATARRAY,
+  GIMP_PDB_STRINGARRAY,
+  GIMP_PDB_COLOR,
+  GIMP_PDB_ITEM,
+  GIMP_PDB_DISPLAY,
+  GIMP_PDB_IMAGE,
+  GIMP_PDB_LAYER,
+  GIMP_PDB_CHANNEL,
+  GIMP_PDB_DRAWABLE,
+  GIMP_PDB_SELECTION,
+  GIMP_PDB_COLORARRAY,
+  GIMP_PDB_VECTORS,
+  GIMP_PDB_PARASITE,
+  GIMP_PDB_STATUS,
+  GIMP_PDB_END,
+
+#ifndef GIMP_DISABLE_DEPRECATED
+  GIMP_PDB_PATH     = GIMP_PDB_VECTORS,     /*< skip >*/
+  GIMP_PDB_BOUNDARY = GIMP_PDB_COLORARRAY,  /*< skip >*/
+  GIMP_PDB_REGION   = GIMP_PDB_ITEM         /*< skip >*/
+#endif /* GIMP_DISABLE_DEPRECATED */
+} GimpPDBArgType;
+
+
+#define GIMP_TYPE_PDB_ERROR_HANDLER (gimp_pdb_error_handler_get_type ())
+
+GType gimp_pdb_error_handler_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_PDB_ERROR_HANDLER_INTERNAL,
+  GIMP_PDB_ERROR_HANDLER_PLUGIN
+} GimpPDBErrorHandler;
+
+
+#define GIMP_TYPE_PDB_PROC_TYPE (gimp_pdb_proc_type_get_type ())
+
+GType gimp_pdb_proc_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_INTERNAL,   /*< desc="Internal GIMP procedure" >*/
+  GIMP_PLUGIN,     /*< desc="GIMP Plug-In" >*/
+  GIMP_EXTENSION,  /*< desc="GIMP Extension" >*/
+  GIMP_TEMPORARY   /*< desc="Temporary Procedure" >*/
+} GimpPDBProcType;
+
+
+#define GIMP_TYPE_PDB_STATUS_TYPE (gimp_pdb_status_type_get_type ())
+
+GType gimp_pdb_status_type_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_PDB_EXECUTION_ERROR,
+  GIMP_PDB_CALLING_ERROR,
+  GIMP_PDB_PASS_THROUGH,
+  GIMP_PDB_SUCCESS,
+  GIMP_PDB_CANCEL
+} GimpPDBStatusType;
+
+
 #define GIMP_TYPE_PRECISION (gimp_precision_get_type ())
 
 GType gimp_precision_get_type (void) G_GNUC_CONST;
@@ -477,6 +565,21 @@ typedef enum
 } GimpPrecision;
 
 
+#define GIMP_TYPE_PROGRESS_COMMAND (gimp_progress_command_get_type ())
+
+GType gimp_progress_command_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_PROGRESS_COMMAND_START,
+  GIMP_PROGRESS_COMMAND_END,
+  GIMP_PROGRESS_COMMAND_SET_TEXT,
+  GIMP_PROGRESS_COMMAND_SET_VALUE,
+  GIMP_PROGRESS_COMMAND_PULSE,
+  GIMP_PROGRESS_COMMAND_GET_WINDOW
+} GimpProgressCommand;
+
+
 #define GIMP_TYPE_REPEAT_MODE (gimp_repeat_mode_get_type ())
 
 GType gimp_repeat_mode_get_type (void) G_GNUC_CONST;
@@ -541,6 +644,55 @@ typedef enum
 } GimpSizeType;
 
 
+#define GIMP_TYPE_STACK_TRACE_MODE (gimp_stack_trace_mode_get_type ())
+
+GType gimp_stack_trace_mode_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_STACK_TRACE_NEVER,
+  GIMP_STACK_TRACE_QUERY,
+  GIMP_STACK_TRACE_ALWAYS
+} GimpStackTraceMode;
+
+
+#define GIMP_TYPE_TEXT_DIRECTION (gimp_text_direction_get_type ())
+
+GType gimp_text_direction_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_TEXT_DIRECTION_LTR,   /*< desc="From left to right" >*/
+  GIMP_TEXT_DIRECTION_RTL    /*< desc="From right to left" >*/
+} GimpTextDirection;
+
+
+#define GIMP_TYPE_TEXT_HINT_STYLE (gimp_text_hint_style_get_type ())
+
+GType gimp_text_hint_style_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_TEXT_HINT_STYLE_NONE,     /*< desc="None"   >*/
+  GIMP_TEXT_HINT_STYLE_SLIGHT,   /*< desc="Slight" >*/
+  GIMP_TEXT_HINT_STYLE_MEDIUM,   /*< desc="Medium" >*/
+  GIMP_TEXT_HINT_STYLE_FULL      /*< desc="Full"   >*/
+} GimpTextHintStyle;
+
+
+#define GIMP_TYPE_TEXT_JUSTIFICATION (gimp_text_justification_get_type ())
+
+GType gimp_text_justification_get_type (void) G_GNUC_CONST;
+
+typedef enum
+{
+  GIMP_TEXT_JUSTIFY_LEFT,    /*< desc="Left justified"  >*/
+  GIMP_TEXT_JUSTIFY_RIGHT,   /*< desc="Right justified" >*/
+  GIMP_TEXT_JUSTIFY_CENTER,  /*< desc="Centered"        >*/
+  GIMP_TEXT_JUSTIFY_FILL     /*< desc="Filled"          >*/
+} GimpTextJustification;
+
+
 #define GIMP_TYPE_TRANSFER_MODE (gimp_transfer_mode_get_type ())
 
 GType gimp_transfer_mode_get_type (void) G_GNUC_CONST;
@@ -598,158 +750,6 @@ typedef enum /*< skip >*/
 } GimpUnit;
 
 
-#define GIMP_TYPE_PDB_ARG_TYPE (gimp_pdb_arg_type_get_type ())
-
-GType gimp_pdb_arg_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_PDB_INT32,
-  GIMP_PDB_INT16,
-  GIMP_PDB_INT8,
-  GIMP_PDB_FLOAT,
-  GIMP_PDB_STRING,
-  GIMP_PDB_INT32ARRAY,
-  GIMP_PDB_INT16ARRAY,
-  GIMP_PDB_INT8ARRAY,
-  GIMP_PDB_FLOATARRAY,
-  GIMP_PDB_STRINGARRAY,
-  GIMP_PDB_COLOR,
-  GIMP_PDB_ITEM,
-  GIMP_PDB_DISPLAY,
-  GIMP_PDB_IMAGE,
-  GIMP_PDB_LAYER,
-  GIMP_PDB_CHANNEL,
-  GIMP_PDB_DRAWABLE,
-  GIMP_PDB_SELECTION,
-  GIMP_PDB_COLORARRAY,
-  GIMP_PDB_VECTORS,
-  GIMP_PDB_PARASITE,
-  GIMP_PDB_STATUS,
-  GIMP_PDB_END,
-
-#ifndef GIMP_DISABLE_DEPRECATED
-  GIMP_PDB_PATH     = GIMP_PDB_VECTORS,     /*< skip >*/
-  GIMP_PDB_BOUNDARY = GIMP_PDB_COLORARRAY,  /*< skip >*/
-  GIMP_PDB_REGION   = GIMP_PDB_ITEM         /*< skip >*/
-#endif /* GIMP_DISABLE_DEPRECATED */
-} GimpPDBArgType;
-
-
-#define GIMP_TYPE_PDB_ERROR_HANDLER (gimp_pdb_error_handler_get_type ())
-
-GType gimp_pdb_error_handler_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_PDB_ERROR_HANDLER_INTERNAL,
-  GIMP_PDB_ERROR_HANDLER_PLUGIN
-} GimpPDBErrorHandler;
-
-
-#define GIMP_TYPE_PDB_PROC_TYPE (gimp_pdb_proc_type_get_type ())
-
-GType gimp_pdb_proc_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_INTERNAL,   /*< desc="Internal GIMP procedure" >*/
-  GIMP_PLUGIN,     /*< desc="GIMP Plug-In" >*/
-  GIMP_EXTENSION,  /*< desc="GIMP Extension" >*/
-  GIMP_TEMPORARY   /*< desc="Temporary Procedure" >*/
-} GimpPDBProcType;
-
-
-#define GIMP_TYPE_PDB_STATUS_TYPE (gimp_pdb_status_type_get_type ())
-
-GType gimp_pdb_status_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_PDB_EXECUTION_ERROR,
-  GIMP_PDB_CALLING_ERROR,
-  GIMP_PDB_PASS_THROUGH,
-  GIMP_PDB_SUCCESS,
-  GIMP_PDB_CANCEL
-} GimpPDBStatusType;
-
-
-#define GIMP_TYPE_MESSAGE_HANDLER_TYPE (gimp_message_handler_type_get_type ())
-
-GType gimp_message_handler_type_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_MESSAGE_BOX,
-  GIMP_CONSOLE,
-  GIMP_ERROR_CONSOLE
-} GimpMessageHandlerType;
-
-
-#define GIMP_TYPE_STACK_TRACE_MODE (gimp_stack_trace_mode_get_type ())
-
-GType gimp_stack_trace_mode_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_STACK_TRACE_NEVER,
-  GIMP_STACK_TRACE_QUERY,
-  GIMP_STACK_TRACE_ALWAYS
-} GimpStackTraceMode;
-
-
-#define GIMP_TYPE_PROGRESS_COMMAND (gimp_progress_command_get_type ())
-
-GType gimp_progress_command_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_PROGRESS_COMMAND_START,
-  GIMP_PROGRESS_COMMAND_END,
-  GIMP_PROGRESS_COMMAND_SET_TEXT,
-  GIMP_PROGRESS_COMMAND_SET_VALUE,
-  GIMP_PROGRESS_COMMAND_PULSE,
-  GIMP_PROGRESS_COMMAND_GET_WINDOW
-} GimpProgressCommand;
-
-
-#define GIMP_TYPE_TEXT_DIRECTION (gimp_text_direction_get_type ())
-
-GType gimp_text_direction_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_TEXT_DIRECTION_LTR,   /*< desc="From left to right" >*/
-  GIMP_TEXT_DIRECTION_RTL    /*< desc="From right to left" >*/
-} GimpTextDirection;
-
-
-#define GIMP_TYPE_TEXT_HINT_STYLE (gimp_text_hint_style_get_type ())
-
-GType gimp_text_hint_style_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_TEXT_HINT_STYLE_NONE,     /*< desc="None"   >*/
-  GIMP_TEXT_HINT_STYLE_SLIGHT,   /*< desc="Slight" >*/
-  GIMP_TEXT_HINT_STYLE_MEDIUM,   /*< desc="Medium" >*/
-  GIMP_TEXT_HINT_STYLE_FULL      /*< desc="Full"   >*/
-} GimpTextHintStyle;
-
-
-#define GIMP_TYPE_TEXT_JUSTIFICATION (gimp_text_justification_get_type ())
-
-GType gimp_text_justification_get_type (void) G_GNUC_CONST;
-
-typedef enum
-{
-  GIMP_TEXT_JUSTIFY_LEFT,    /*< desc="Left justified"  >*/
-  GIMP_TEXT_JUSTIFY_RIGHT,   /*< desc="Right justified" >*/
-  GIMP_TEXT_JUSTIFY_CENTER,  /*< desc="Centered"        >*/
-  GIMP_TEXT_JUSTIFY_FILL     /*< desc="Filled"          >*/
-} GimpTextJustification;
-
-
 #ifndef GIMP_DISABLE_DEPRECATED
 #define GIMP_TYPE_USER_DIRECTORY (gimp_user_directory_get_type ())
 
diff --git a/tools/pdbgen/enums.pl b/tools/pdbgen/enums.pl
index 439c8e8..9c98ef0 100644
--- a/tools/pdbgen/enums.pl
+++ b/tools/pdbgen/enums.pl
@@ -86,6 +86,13 @@ package Gimp::CodeGen::enums;
                       GIMP_INDEXED_CHANNEL => '4',
                       GIMP_ALPHA_CHANNEL => '5' }
        },
+    GimpCloneType =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_CLONE_IMAGE GIMP_CLONE_PATTERN) ],
+         mapping => { GIMP_CLONE_IMAGE => '0',
+                      GIMP_CLONE_PATTERN => '1' }
+       },
     GimpComponentType =>
        { contig => 0,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -107,13 +114,6 @@ package Gimp::CodeGen::enums;
          mapping => { GIMP_CONVOLVE_BLUR => '0',
                       GIMP_CONVOLVE_SHARPEN => '1' }
        },
-    GimpCloneType =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_CLONE_IMAGE GIMP_CLONE_PATTERN) ],
-         mapping => { GIMP_CLONE_IMAGE => '0',
-                      GIMP_CLONE_PATTERN => '1' }
-       },
     GimpDesaturateMode =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -151,30 +151,6 @@ package Gimp::CodeGen::enums;
          mapping => { GIMP_FOREGROUND_EXTRACT_SIOX => '0',
                       GIMP_FOREGROUND_EXTRACT_MATTING => '1' }
        },
-    GimpGradientType =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_GRADIENT_LINEAR GIMP_GRADIENT_BILINEAR
-                         GIMP_GRADIENT_RADIAL GIMP_GRADIENT_SQUARE
-                         GIMP_GRADIENT_CONICAL_SYMMETRIC
-                         GIMP_GRADIENT_CONICAL_ASYMMETRIC
-                         GIMP_GRADIENT_SHAPEBURST_ANGULAR
-                         GIMP_GRADIENT_SHAPEBURST_SPHERICAL
-                         GIMP_GRADIENT_SHAPEBURST_DIMPLED
-                         GIMP_GRADIENT_SPIRAL_CLOCKWISE
-                         GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE) ],
-         mapping => { GIMP_GRADIENT_LINEAR => '0',
-                      GIMP_GRADIENT_BILINEAR => '1',
-                      GIMP_GRADIENT_RADIAL => '2',
-                      GIMP_GRADIENT_SQUARE => '3',
-                      GIMP_GRADIENT_CONICAL_SYMMETRIC => '4',
-                      GIMP_GRADIENT_CONICAL_ASYMMETRIC => '5',
-                      GIMP_GRADIENT_SHAPEBURST_ANGULAR => '6',
-                      GIMP_GRADIENT_SHAPEBURST_SPHERICAL => '7',
-                      GIMP_GRADIENT_SHAPEBURST_DIMPLED => '8',
-                      GIMP_GRADIENT_SPIRAL_CLOCKWISE => '9',
-                      GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE => '10' }
-       },
     GimpGradientSegmentColor =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -199,6 +175,30 @@ package Gimp::CodeGen::enums;
                       GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING => '3',
                       GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING => '4' }
        },
+    GimpGradientType =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_GRADIENT_LINEAR GIMP_GRADIENT_BILINEAR
+                         GIMP_GRADIENT_RADIAL GIMP_GRADIENT_SQUARE
+                         GIMP_GRADIENT_CONICAL_SYMMETRIC
+                         GIMP_GRADIENT_CONICAL_ASYMMETRIC
+                         GIMP_GRADIENT_SHAPEBURST_ANGULAR
+                         GIMP_GRADIENT_SHAPEBURST_SPHERICAL
+                         GIMP_GRADIENT_SHAPEBURST_DIMPLED
+                         GIMP_GRADIENT_SPIRAL_CLOCKWISE
+                         GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE) ],
+         mapping => { GIMP_GRADIENT_LINEAR => '0',
+                      GIMP_GRADIENT_BILINEAR => '1',
+                      GIMP_GRADIENT_RADIAL => '2',
+                      GIMP_GRADIENT_SQUARE => '3',
+                      GIMP_GRADIENT_CONICAL_SYMMETRIC => '4',
+                      GIMP_GRADIENT_CONICAL_ASYMMETRIC => '5',
+                      GIMP_GRADIENT_SHAPEBURST_ANGULAR => '6',
+                      GIMP_GRADIENT_SHAPEBURST_SPHERICAL => '7',
+                      GIMP_GRADIENT_SHAPEBURST_DIMPLED => '8',
+                      GIMP_GRADIENT_SPIRAL_CLOCKWISE => '9',
+                      GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE => '10' }
+       },
     GimpGridStyle =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -281,6 +281,14 @@ package Gimp::CodeGen::enums;
                       GIMP_CLIP_TO_BOTTOM_LAYER => '2',
                       GIMP_FLATTEN_IMAGE => '3' }
        },
+    GimpMessageHandlerType =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_MESSAGE_BOX GIMP_CONSOLE GIMP_ERROR_CONSOLE) ],
+         mapping => { GIMP_MESSAGE_BOX => '0',
+                      GIMP_CONSOLE => '1',
+                      GIMP_ERROR_CONSOLE => '2' }
+       },
     GimpOffsetType =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -304,120 +312,6 @@ package Gimp::CodeGen::enums;
          mapping => { GIMP_PAINT_CONSTANT => '0',
                       GIMP_PAINT_INCREMENTAL => '1' }
        },
-    GimpPrecision =>
-       { contig => 0,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_PRECISION_U8_LINEAR GIMP_PRECISION_U8_GAMMA
-                         GIMP_PRECISION_U16_LINEAR GIMP_PRECISION_U16_GAMMA
-                         GIMP_PRECISION_U32_LINEAR GIMP_PRECISION_U32_GAMMA
-                         GIMP_PRECISION_HALF_LINEAR
-                         GIMP_PRECISION_HALF_GAMMA
-                         GIMP_PRECISION_FLOAT_LINEAR
-                         GIMP_PRECISION_FLOAT_GAMMA
-                         GIMP_PRECISION_DOUBLE_LINEAR
-                         GIMP_PRECISION_DOUBLE_GAMMA) ],
-         mapping => { GIMP_PRECISION_U8_LINEAR => '100',
-                      GIMP_PRECISION_U8_GAMMA => '150',
-                      GIMP_PRECISION_U16_LINEAR => '200',
-                      GIMP_PRECISION_U16_GAMMA => '250',
-                      GIMP_PRECISION_U32_LINEAR => '300',
-                      GIMP_PRECISION_U32_GAMMA => '350',
-                      GIMP_PRECISION_HALF_LINEAR => '500',
-                      GIMP_PRECISION_HALF_GAMMA => '550',
-                      GIMP_PRECISION_FLOAT_LINEAR => '600',
-                      GIMP_PRECISION_FLOAT_GAMMA => '650',
-                      GIMP_PRECISION_DOUBLE_LINEAR => '700',
-                      GIMP_PRECISION_DOUBLE_GAMMA => '750' }
-       },
-    GimpRepeatMode =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_REPEAT_NONE GIMP_REPEAT_SAWTOOTH
-                         GIMP_REPEAT_TRIANGULAR GIMP_REPEAT_TRUNCATE) ],
-         mapping => { GIMP_REPEAT_NONE => '0',
-                      GIMP_REPEAT_SAWTOOTH => '1',
-                      GIMP_REPEAT_TRIANGULAR => '2',
-                      GIMP_REPEAT_TRUNCATE => '3' }
-       },
-    GimpRotationType =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_ROTATE_90 GIMP_ROTATE_180 GIMP_ROTATE_270) ],
-         mapping => { GIMP_ROTATE_90 => '0',
-                      GIMP_ROTATE_180 => '1',
-                      GIMP_ROTATE_270 => '2' }
-       },
-    GimpRunMode =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_RUN_INTERACTIVE GIMP_RUN_NONINTERACTIVE
-                         GIMP_RUN_WITH_LAST_VALS) ],
-         mapping => { GIMP_RUN_INTERACTIVE => '0',
-                      GIMP_RUN_NONINTERACTIVE => '1',
-                      GIMP_RUN_WITH_LAST_VALS => '2' }
-       },
-    GimpSelectCriterion =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_SELECT_CRITERION_COMPOSITE
-                         GIMP_SELECT_CRITERION_R GIMP_SELECT_CRITERION_G
-                         GIMP_SELECT_CRITERION_B GIMP_SELECT_CRITERION_H
-                         GIMP_SELECT_CRITERION_S GIMP_SELECT_CRITERION_V) ],
-         mapping => { GIMP_SELECT_CRITERION_COMPOSITE => '0',
-                      GIMP_SELECT_CRITERION_R => '1',
-                      GIMP_SELECT_CRITERION_G => '2',
-                      GIMP_SELECT_CRITERION_B => '3',
-                      GIMP_SELECT_CRITERION_H => '4',
-                      GIMP_SELECT_CRITERION_S => '5',
-                      GIMP_SELECT_CRITERION_V => '6' }
-       },
-    GimpSizeType =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_PIXELS GIMP_POINTS) ],
-         mapping => { GIMP_PIXELS => '0',
-                      GIMP_POINTS => '1' }
-       },
-    GimpTransferMode =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_TRANSFER_SHADOWS GIMP_TRANSFER_MIDTONES
-                         GIMP_TRANSFER_HIGHLIGHTS) ],
-         mapping => { GIMP_TRANSFER_SHADOWS => '0',
-                      GIMP_TRANSFER_MIDTONES => '1',
-                      GIMP_TRANSFER_HIGHLIGHTS => '2' }
-       },
-    GimpTransformDirection =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_TRANSFORM_FORWARD GIMP_TRANSFORM_BACKWARD) ],
-         mapping => { GIMP_TRANSFORM_FORWARD => '0',
-                      GIMP_TRANSFORM_BACKWARD => '1' }
-       },
-    GimpTransformResize =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_TRANSFORM_RESIZE_ADJUST
-                         GIMP_TRANSFORM_RESIZE_CLIP
-                         GIMP_TRANSFORM_RESIZE_CROP
-                         GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT) ],
-         mapping => { GIMP_TRANSFORM_RESIZE_ADJUST => '0',
-                      GIMP_TRANSFORM_RESIZE_CLIP => '1',
-                      GIMP_TRANSFORM_RESIZE_CROP => '2',
-                      GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT => '3' }
-       },
-    GimpUnit =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_UNIT_PIXEL GIMP_UNIT_INCH GIMP_UNIT_MM
-                         GIMP_UNIT_POINT GIMP_UNIT_PICA GIMP_UNIT_END) ],
-         mapping => { GIMP_UNIT_PIXEL => '0',
-                      GIMP_UNIT_INCH => '1',
-                      GIMP_UNIT_MM => '2',
-                      GIMP_UNIT_POINT => '3',
-                      GIMP_UNIT_PICA => '4',
-                      GIMP_UNIT_END => '5' }
-       },
     GimpPDBArgType =>
        { contig => 0,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -488,22 +382,30 @@ package Gimp::CodeGen::enums;
                       GIMP_PDB_SUCCESS => '3',
                       GIMP_PDB_CANCEL => '4' }
        },
-    GimpMessageHandlerType =>
-       { contig => 1,
-         header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_MESSAGE_BOX GIMP_CONSOLE GIMP_ERROR_CONSOLE) ],
-         mapping => { GIMP_MESSAGE_BOX => '0',
-                      GIMP_CONSOLE => '1',
-                      GIMP_ERROR_CONSOLE => '2' }
-       },
-    GimpStackTraceMode =>
-       { contig => 1,
+    GimpPrecision =>
+       { contig => 0,
          header => 'libgimpbase/gimpbaseenums.h',
-         symbols => [ qw(GIMP_STACK_TRACE_NEVER GIMP_STACK_TRACE_QUERY
-                         GIMP_STACK_TRACE_ALWAYS) ],
-         mapping => { GIMP_STACK_TRACE_NEVER => '0',
-                      GIMP_STACK_TRACE_QUERY => '1',
-                      GIMP_STACK_TRACE_ALWAYS => '2' }
+         symbols => [ qw(GIMP_PRECISION_U8_LINEAR GIMP_PRECISION_U8_GAMMA
+                         GIMP_PRECISION_U16_LINEAR GIMP_PRECISION_U16_GAMMA
+                         GIMP_PRECISION_U32_LINEAR GIMP_PRECISION_U32_GAMMA
+                         GIMP_PRECISION_HALF_LINEAR
+                         GIMP_PRECISION_HALF_GAMMA
+                         GIMP_PRECISION_FLOAT_LINEAR
+                         GIMP_PRECISION_FLOAT_GAMMA
+                         GIMP_PRECISION_DOUBLE_LINEAR
+                         GIMP_PRECISION_DOUBLE_GAMMA) ],
+         mapping => { GIMP_PRECISION_U8_LINEAR => '100',
+                      GIMP_PRECISION_U8_GAMMA => '150',
+                      GIMP_PRECISION_U16_LINEAR => '200',
+                      GIMP_PRECISION_U16_GAMMA => '250',
+                      GIMP_PRECISION_U32_LINEAR => '300',
+                      GIMP_PRECISION_U32_GAMMA => '350',
+                      GIMP_PRECISION_HALF_LINEAR => '500',
+                      GIMP_PRECISION_HALF_GAMMA => '550',
+                      GIMP_PRECISION_FLOAT_LINEAR => '600',
+                      GIMP_PRECISION_FLOAT_GAMMA => '650',
+                      GIMP_PRECISION_DOUBLE_LINEAR => '700',
+                      GIMP_PRECISION_DOUBLE_GAMMA => '750' }
        },
     GimpProgressCommand =>
        { contig => 1,
@@ -521,6 +423,64 @@ package Gimp::CodeGen::enums;
                       GIMP_PROGRESS_COMMAND_PULSE => '4',
                       GIMP_PROGRESS_COMMAND_GET_WINDOW => '5' }
        },
+    GimpRepeatMode =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_REPEAT_NONE GIMP_REPEAT_SAWTOOTH
+                         GIMP_REPEAT_TRIANGULAR GIMP_REPEAT_TRUNCATE) ],
+         mapping => { GIMP_REPEAT_NONE => '0',
+                      GIMP_REPEAT_SAWTOOTH => '1',
+                      GIMP_REPEAT_TRIANGULAR => '2',
+                      GIMP_REPEAT_TRUNCATE => '3' }
+       },
+    GimpRotationType =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_ROTATE_90 GIMP_ROTATE_180 GIMP_ROTATE_270) ],
+         mapping => { GIMP_ROTATE_90 => '0',
+                      GIMP_ROTATE_180 => '1',
+                      GIMP_ROTATE_270 => '2' }
+       },
+    GimpRunMode =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_RUN_INTERACTIVE GIMP_RUN_NONINTERACTIVE
+                         GIMP_RUN_WITH_LAST_VALS) ],
+         mapping => { GIMP_RUN_INTERACTIVE => '0',
+                      GIMP_RUN_NONINTERACTIVE => '1',
+                      GIMP_RUN_WITH_LAST_VALS => '2' }
+       },
+    GimpSelectCriterion =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_SELECT_CRITERION_COMPOSITE
+                         GIMP_SELECT_CRITERION_R GIMP_SELECT_CRITERION_G
+                         GIMP_SELECT_CRITERION_B GIMP_SELECT_CRITERION_H
+                         GIMP_SELECT_CRITERION_S GIMP_SELECT_CRITERION_V) ],
+         mapping => { GIMP_SELECT_CRITERION_COMPOSITE => '0',
+                      GIMP_SELECT_CRITERION_R => '1',
+                      GIMP_SELECT_CRITERION_G => '2',
+                      GIMP_SELECT_CRITERION_B => '3',
+                      GIMP_SELECT_CRITERION_H => '4',
+                      GIMP_SELECT_CRITERION_S => '5',
+                      GIMP_SELECT_CRITERION_V => '6' }
+       },
+    GimpSizeType =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_PIXELS GIMP_POINTS) ],
+         mapping => { GIMP_PIXELS => '0',
+                      GIMP_POINTS => '1' }
+       },
+    GimpStackTraceMode =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_STACK_TRACE_NEVER GIMP_STACK_TRACE_QUERY
+                         GIMP_STACK_TRACE_ALWAYS) ],
+         mapping => { GIMP_STACK_TRACE_NEVER => '0',
+                      GIMP_STACK_TRACE_QUERY => '1',
+                      GIMP_STACK_TRACE_ALWAYS => '2' }
+       },
     GimpTextDirection =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',
@@ -550,6 +510,46 @@ package Gimp::CodeGen::enums;
                       GIMP_TEXT_JUSTIFY_CENTER => '2',
                       GIMP_TEXT_JUSTIFY_FILL => '3' }
        },
+    GimpTransferMode =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_TRANSFER_SHADOWS GIMP_TRANSFER_MIDTONES
+                         GIMP_TRANSFER_HIGHLIGHTS) ],
+         mapping => { GIMP_TRANSFER_SHADOWS => '0',
+                      GIMP_TRANSFER_MIDTONES => '1',
+                      GIMP_TRANSFER_HIGHLIGHTS => '2' }
+       },
+    GimpTransformDirection =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_TRANSFORM_FORWARD GIMP_TRANSFORM_BACKWARD) ],
+         mapping => { GIMP_TRANSFORM_FORWARD => '0',
+                      GIMP_TRANSFORM_BACKWARD => '1' }
+       },
+    GimpTransformResize =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_TRANSFORM_RESIZE_ADJUST
+                         GIMP_TRANSFORM_RESIZE_CLIP
+                         GIMP_TRANSFORM_RESIZE_CROP
+                         GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT) ],
+         mapping => { GIMP_TRANSFORM_RESIZE_ADJUST => '0',
+                      GIMP_TRANSFORM_RESIZE_CLIP => '1',
+                      GIMP_TRANSFORM_RESIZE_CROP => '2',
+                      GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT => '3' }
+       },
+    GimpUnit =>
+       { contig => 1,
+         header => 'libgimpbase/gimpbaseenums.h',
+         symbols => [ qw(GIMP_UNIT_PIXEL GIMP_UNIT_INCH GIMP_UNIT_MM
+                         GIMP_UNIT_POINT GIMP_UNIT_PICA GIMP_UNIT_END) ],
+         mapping => { GIMP_UNIT_PIXEL => '0',
+                      GIMP_UNIT_INCH => '1',
+                      GIMP_UNIT_MM => '2',
+                      GIMP_UNIT_POINT => '3',
+                      GIMP_UNIT_PICA => '4',
+                      GIMP_UNIT_END => '5' }
+       },
     GimpUserDirectory =>
        { contig => 1,
          header => 'libgimpbase/gimpbaseenums.h',



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