diff --git a/ChangeLog b/ChangeLog
index c625d89226..d00a6176c1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,47 @@
+2004-10-25  Michael Natterer  <mitch@gimp.org>
+
+	Don't store human readable and translatable enum/flag strings in
+	GEnumValue's and GTypeValue's fields but attach them to their
+	GType using separate structs and utility functions:
+
+	* tools/gimp-mkenums: added params and perl voodoo to support
+	generating a second array of values, which is used by the
+	Makefiles below to create and register arrays of value
+	descriptions.
+
+	* libgimpbase/gimpbasetypes.[ch]: added API to attach/retreive
+	arrays of translatable strings to/from enum and flags types. Added
+	structs GimpEnumDesc and GimpFlagsDesc for that purpose.
+
+	* libgimpbase/gimputils.[ch]: changed existing enum utility
+	functions, added new ones and added a symmetric API for flags.
+
+	* app/base/Makefile.am
+	* app/core/Makefile.am
+	* app/display/Makefile.am
+	* app/paint/Makefile.am
+	* app/text/Makefile.am
+	* app/tools/Makefile.am
+	* app/widgets/Makefile.am
+	* libgimp/Makefile.am
+	* libgimpbase/Makefile.am: changed *-enums.c generation rules
+	accordingly.
+
+	* app/base/base-enums.c
+	* app/core/core-enums.c
+	* app/display/display-enums.c
+	* app/paint/paint-enums.c
+	* app/text/text-enums.c
+	* app/tools/tools-enums.c
+	* app/widgets/widgets-enums.c
+	* libgimpbase/gimpbaseenums.c: regenerated.
+
+	* app/widgets/gimpenumstore.c
+	* app/widgets/gimpenumwidgets.c
+	* app/widgets/gimptemplateeditor.c
+	* libgimpwidgets/gimppreviewarea.c: follow the enum utility
+	function API changes.
+
 2004-10-25  Sven Neumann  <sven@gimp.org>
 
 	* plug-ins/imagemap/imap_cmd_gimp_guides.c
diff --git a/app/base/Makefile.am b/app/base/Makefile.am
index d8948b2f66..816e27467d 100644
--- a/app/base/Makefile.am
+++ b/app/base/Makefile.am
@@ -90,11 +90,14 @@ CLEANFILES = $(EXTRA_PROGRAMS) $(gen_sources)
 
 $(srcdir)/base-enums.c: $(srcdir)/base-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"base-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"base-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/base-enums.h > xgen-bec \
 	&& cp xgen-bec $(@F) \
 	&& rm -f xgen-bec
diff --git a/app/base/base-enums.c b/app/base/base-enums.c
index 066fb99a79..d71f4eab8d 100644
--- a/app/base/base-enums.c
+++ b/app/base/base-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "base-enums.h"
 #include "gimp-intl.h"
 
@@ -12,15 +13,25 @@ gimp_curve_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CURVE_SMOOTH, N_("Smooth"), "smooth" },
-    { GIMP_CURVE_FREE, N_("Freehand"), "free" },
+    { GIMP_CURVE_SMOOTH, "GIMP_CURVE_SMOOTH", "smooth" },
+    { GIMP_CURVE_FREE, "GIMP_CURVE_FREE", "free" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CURVE_SMOOTH, N_("Smooth"), NULL },
+    { GIMP_CURVE_FREE, N_("Freehand"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCurveType", values);
+    {
+      type = g_enum_register_static ("GimpCurveType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -30,19 +41,33 @@ gimp_histogram_channel_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_HISTOGRAM_VALUE, N_("Value"), "value" },
-    { GIMP_HISTOGRAM_RED, N_("Red"), "red" },
-    { GIMP_HISTOGRAM_GREEN, N_("Green"), "green" },
-    { GIMP_HISTOGRAM_BLUE, N_("Blue"), "blue" },
-    { GIMP_HISTOGRAM_ALPHA, N_("Alpha"), "alpha" },
-    { GIMP_HISTOGRAM_RGB, N_("RGB"), "rgb" },
+    { GIMP_HISTOGRAM_VALUE, "GIMP_HISTOGRAM_VALUE", "value" },
+    { GIMP_HISTOGRAM_RED, "GIMP_HISTOGRAM_RED", "red" },
+    { GIMP_HISTOGRAM_GREEN, "GIMP_HISTOGRAM_GREEN", "green" },
+    { GIMP_HISTOGRAM_BLUE, "GIMP_HISTOGRAM_BLUE", "blue" },
+    { GIMP_HISTOGRAM_ALPHA, "GIMP_HISTOGRAM_ALPHA", "alpha" },
+    { GIMP_HISTOGRAM_RGB, "GIMP_HISTOGRAM_RGB", "rgb" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_HISTOGRAM_VALUE, N_("Value"), NULL },
+    { GIMP_HISTOGRAM_RED, N_("Red"), NULL },
+    { GIMP_HISTOGRAM_GREEN, N_("Green"), NULL },
+    { GIMP_HISTOGRAM_BLUE, N_("Blue"), NULL },
+    { GIMP_HISTOGRAM_ALPHA, N_("Alpha"), NULL },
+    { GIMP_HISTOGRAM_RGB, N_("RGB"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpHistogramChannel", values);
+    {
+      type = g_enum_register_static ("GimpHistogramChannel", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -52,16 +77,27 @@ gimp_interpolation_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_INTERPOLATION_NONE, N_("None (Fastest)"), "none" },
-    { GIMP_INTERPOLATION_LINEAR, N_("Linear"), "linear" },
-    { GIMP_INTERPOLATION_CUBIC, N_("Cubic (Best)"), "cubic" },
+    { GIMP_INTERPOLATION_NONE, "GIMP_INTERPOLATION_NONE", "none" },
+    { GIMP_INTERPOLATION_LINEAR, "GIMP_INTERPOLATION_LINEAR", "linear" },
+    { GIMP_INTERPOLATION_CUBIC, "GIMP_INTERPOLATION_CUBIC", "cubic" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_INTERPOLATION_NONE, N_("None (Fastest)"), NULL },
+    { GIMP_INTERPOLATION_LINEAR, N_("Linear"), NULL },
+    { GIMP_INTERPOLATION_CUBIC, N_("Cubic (Best)"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpInterpolationType", values);
+    {
+      type = g_enum_register_static ("GimpInterpolationType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -97,10 +133,41 @@ gimp_layer_mode_effects_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_NORMAL_MODE, "GIMP_NORMAL_MODE", NULL },
+    { GIMP_DISSOLVE_MODE, "GIMP_DISSOLVE_MODE", NULL },
+    { GIMP_BEHIND_MODE, "GIMP_BEHIND_MODE", NULL },
+    { GIMP_MULTIPLY_MODE, "GIMP_MULTIPLY_MODE", NULL },
+    { GIMP_SCREEN_MODE, "GIMP_SCREEN_MODE", NULL },
+    { GIMP_OVERLAY_MODE, "GIMP_OVERLAY_MODE", NULL },
+    { GIMP_DIFFERENCE_MODE, "GIMP_DIFFERENCE_MODE", NULL },
+    { GIMP_ADDITION_MODE, "GIMP_ADDITION_MODE", NULL },
+    { GIMP_SUBTRACT_MODE, "GIMP_SUBTRACT_MODE", NULL },
+    { GIMP_DARKEN_ONLY_MODE, "GIMP_DARKEN_ONLY_MODE", NULL },
+    { GIMP_LIGHTEN_ONLY_MODE, "GIMP_LIGHTEN_ONLY_MODE", NULL },
+    { GIMP_HUE_MODE, "GIMP_HUE_MODE", NULL },
+    { GIMP_SATURATION_MODE, "GIMP_SATURATION_MODE", NULL },
+    { GIMP_COLOR_MODE, "GIMP_COLOR_MODE", NULL },
+    { GIMP_VALUE_MODE, "GIMP_VALUE_MODE", NULL },
+    { GIMP_DIVIDE_MODE, "GIMP_DIVIDE_MODE", NULL },
+    { GIMP_DODGE_MODE, "GIMP_DODGE_MODE", NULL },
+    { GIMP_BURN_MODE, "GIMP_BURN_MODE", NULL },
+    { GIMP_HARDLIGHT_MODE, "GIMP_HARDLIGHT_MODE", NULL },
+    { GIMP_SOFTLIGHT_MODE, "GIMP_SOFTLIGHT_MODE", NULL },
+    { GIMP_GRAIN_EXTRACT_MODE, "GIMP_GRAIN_EXTRACT_MODE", NULL },
+    { GIMP_GRAIN_MERGE_MODE, "GIMP_GRAIN_MERGE_MODE", NULL },
+    { GIMP_COLOR_ERASE_MODE, "GIMP_COLOR_ERASE_MODE", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpLayerModeEffects", values);
+    {
+      type = g_enum_register_static ("GimpLayerModeEffects", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -110,16 +177,27 @@ gimp_transfer_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_SHADOWS, N_("Shadows"), "shadows" },
-    { GIMP_MIDTONES, N_("Midtones"), "midtones" },
-    { GIMP_HIGHLIGHTS, N_("Highlights"), "highlights" },
+    { GIMP_SHADOWS, "GIMP_SHADOWS", "shadows" },
+    { GIMP_MIDTONES, "GIMP_MIDTONES", "midtones" },
+    { GIMP_HIGHLIGHTS, "GIMP_HIGHLIGHTS", "highlights" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_SHADOWS, N_("Shadows"), NULL },
+    { GIMP_MIDTONES, N_("Midtones"), NULL },
+    { GIMP_HIGHLIGHTS, N_("Highlights"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTransferMode", values);
+    {
+      type = g_enum_register_static ("GimpTransferMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/core/Makefile.am b/app/core/Makefile.am
index 387beeeaf0..fa5b7ff090 100644
--- a/app/core/Makefile.am
+++ b/app/core/Makefile.am
@@ -253,11 +253,14 @@ $(srcdir)/gimpmarshal.c: $(srcdir)/gimpmarshal.h
 
 $(srcdir)/core-enums.c: $(srcdir)/core-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"core-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"core-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/core-enums.h > xgen-cec \
 	&& cp xgen-cec $(@F) \
 	&& rm -f xgen-cec
diff --git a/app/core/core-enums.c b/app/core/core-enums.c
index 626fdcc7f5..de66c33de7 100644
--- a/app/core/core-enums.c
+++ b/app/core/core-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "core-enums.h"
 #include "gimp-intl.h"
 
@@ -12,19 +13,33 @@ gimp_add_mask_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ADD_WHITE_MASK, N_("_White (full opacity)"), "white-mask" },
-    { GIMP_ADD_BLACK_MASK, N_("_Black (full transparency)"), "black-mask" },
-    { GIMP_ADD_ALPHA_MASK, N_("Layer's _alpha channel"), "alpha-mask" },
-    { GIMP_ADD_ALPHA_TRANSFER_MASK, N_("_Transfer layer's alpha channel"), "alpha-transfer-mask" },
-    { GIMP_ADD_SELECTION_MASK, N_("_Selection"), "selection-mask" },
-    { GIMP_ADD_COPY_MASK, N_("_Grayscale copy of layer"), "copy-mask" },
+    { GIMP_ADD_WHITE_MASK, "GIMP_ADD_WHITE_MASK", "white-mask" },
+    { GIMP_ADD_BLACK_MASK, "GIMP_ADD_BLACK_MASK", "black-mask" },
+    { GIMP_ADD_ALPHA_MASK, "GIMP_ADD_ALPHA_MASK", "alpha-mask" },
+    { GIMP_ADD_ALPHA_TRANSFER_MASK, "GIMP_ADD_ALPHA_TRANSFER_MASK", "alpha-transfer-mask" },
+    { GIMP_ADD_SELECTION_MASK, "GIMP_ADD_SELECTION_MASK", "selection-mask" },
+    { GIMP_ADD_COPY_MASK, "GIMP_ADD_COPY_MASK", "copy-mask" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_ADD_WHITE_MASK, N_("_White (full opacity)"), NULL },
+    { GIMP_ADD_BLACK_MASK, N_("_Black (full transparency)"), NULL },
+    { GIMP_ADD_ALPHA_MASK, N_("Layer's _alpha channel"), NULL },
+    { GIMP_ADD_ALPHA_TRANSFER_MASK, N_("_Transfer layer's alpha channel"), NULL },
+    { GIMP_ADD_SELECTION_MASK, N_("_Selection"), NULL },
+    { GIMP_ADD_COPY_MASK, N_("_Grayscale copy of layer"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpAddMaskType", values);
+    {
+      type = g_enum_register_static ("GimpAddMaskType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -34,17 +49,29 @@ gimp_blend_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_FG_BG_RGB_MODE, N_("FG to BG (RGB)"), "fg-bg-rgb-mode" },
-    { GIMP_FG_BG_HSV_MODE, N_("FG to BG (HSV)"), "fg-bg-hsv-mode" },
-    { GIMP_FG_TRANSPARENT_MODE, N_("FG to transparent"), "fg-transparent-mode" },
-    { GIMP_CUSTOM_MODE, N_("Custom gradient"), "custom-mode" },
+    { GIMP_FG_BG_RGB_MODE, "GIMP_FG_BG_RGB_MODE", "fg-bg-rgb-mode" },
+    { GIMP_FG_BG_HSV_MODE, "GIMP_FG_BG_HSV_MODE", "fg-bg-hsv-mode" },
+    { GIMP_FG_TRANSPARENT_MODE, "GIMP_FG_TRANSPARENT_MODE", "fg-transparent-mode" },
+    { GIMP_CUSTOM_MODE, "GIMP_CUSTOM_MODE", "custom-mode" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_FG_BG_RGB_MODE, N_("FG to BG (RGB)"), NULL },
+    { GIMP_FG_BG_HSV_MODE, N_("FG to BG (HSV)"), NULL },
+    { GIMP_FG_TRANSPARENT_MODE, N_("FG to transparent"), NULL },
+    { GIMP_CUSTOM_MODE, N_("Custom gradient"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpBlendMode", values);
+    {
+      type = g_enum_register_static ("GimpBlendMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -54,16 +81,27 @@ gimp_bucket_fill_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_FG_BUCKET_FILL, N_("FG color fill"), "fg-bucket-fill" },
-    { GIMP_BG_BUCKET_FILL, N_("BG color fill"), "bg-bucket-fill" },
-    { GIMP_PATTERN_BUCKET_FILL, N_("Pattern fill"), "pattern-bucket-fill" },
+    { GIMP_FG_BUCKET_FILL, "GIMP_FG_BUCKET_FILL", "fg-bucket-fill" },
+    { GIMP_BG_BUCKET_FILL, "GIMP_BG_BUCKET_FILL", "bg-bucket-fill" },
+    { GIMP_PATTERN_BUCKET_FILL, "GIMP_PATTERN_BUCKET_FILL", "pattern-bucket-fill" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_FG_BUCKET_FILL, N_("FG color fill"), NULL },
+    { GIMP_BG_BUCKET_FILL, N_("BG color fill"), NULL },
+    { GIMP_PATTERN_BUCKET_FILL, N_("Pattern fill"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpBucketFillMode", values);
+    {
+      type = g_enum_register_static ("GimpBucketFillMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -73,17 +111,29 @@ gimp_channel_ops_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CHANNEL_OP_ADD, N_("Add to the current selection"), "add" },
-    { GIMP_CHANNEL_OP_SUBTRACT, N_("Subtract from the current selection"), "subtract" },
-    { GIMP_CHANNEL_OP_REPLACE, N_("Replace the current selection"), "replace" },
-    { GIMP_CHANNEL_OP_INTERSECT, N_("Intersect with the current selection"), "intersect" },
+    { GIMP_CHANNEL_OP_ADD, "GIMP_CHANNEL_OP_ADD", "add" },
+    { GIMP_CHANNEL_OP_SUBTRACT, "GIMP_CHANNEL_OP_SUBTRACT", "subtract" },
+    { GIMP_CHANNEL_OP_REPLACE, "GIMP_CHANNEL_OP_REPLACE", "replace" },
+    { GIMP_CHANNEL_OP_INTERSECT, "GIMP_CHANNEL_OP_INTERSECT", "intersect" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CHANNEL_OP_ADD, N_("Add to the current selection"), NULL },
+    { GIMP_CHANNEL_OP_SUBTRACT, N_("Subtract from the current selection"), NULL },
+    { GIMP_CHANNEL_OP_REPLACE, N_("Replace the current selection"), NULL },
+    { GIMP_CHANNEL_OP_INTERSECT, N_("Intersect with the current selection"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpChannelOps", values);
+    {
+      type = g_enum_register_static ("GimpChannelOps", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -93,19 +143,33 @@ gimp_channel_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_RED_CHANNEL, N_("Red"), "red-channel" },
-    { GIMP_GREEN_CHANNEL, N_("Green"), "green-channel" },
-    { GIMP_BLUE_CHANNEL, N_("Blue"), "blue-channel" },
-    { GIMP_GRAY_CHANNEL, N_("Gray"), "gray-channel" },
-    { GIMP_INDEXED_CHANNEL, N_("Indexed"), "indexed-channel" },
-    { GIMP_ALPHA_CHANNEL, N_("Alpha"), "alpha-channel" },
+    { GIMP_RED_CHANNEL, "GIMP_RED_CHANNEL", "red-channel" },
+    { GIMP_GREEN_CHANNEL, "GIMP_GREEN_CHANNEL", "green-channel" },
+    { GIMP_BLUE_CHANNEL, "GIMP_BLUE_CHANNEL", "blue-channel" },
+    { GIMP_GRAY_CHANNEL, "GIMP_GRAY_CHANNEL", "gray-channel" },
+    { GIMP_INDEXED_CHANNEL, "GIMP_INDEXED_CHANNEL", "indexed-channel" },
+    { GIMP_ALPHA_CHANNEL, "GIMP_ALPHA_CHANNEL", "alpha-channel" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_RED_CHANNEL, N_("Red"), NULL },
+    { GIMP_GREEN_CHANNEL, N_("Green"), NULL },
+    { GIMP_BLUE_CHANNEL, N_("Blue"), NULL },
+    { GIMP_GRAY_CHANNEL, N_("Gray"), NULL },
+    { GIMP_INDEXED_CHANNEL, N_("Indexed"), NULL },
+    { GIMP_ALPHA_CHANNEL, N_("Alpha"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpChannelType", values);
+    {
+      type = g_enum_register_static ("GimpChannelType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -120,10 +184,20 @@ gimp_container_policy_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CONTAINER_POLICY_STRONG, "GIMP_CONTAINER_POLICY_STRONG", NULL },
+    { GIMP_CONTAINER_POLICY_WEAK, "GIMP_CONTAINER_POLICY_WEAK", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpContainerPolicy", values);
+    {
+      type = g_enum_register_static ("GimpContainerPolicy", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -133,17 +207,29 @@ gimp_convert_dither_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_NO_DITHER, N_("None"), "no-dither" },
-    { GIMP_FS_DITHER, N_("Floyd-Steinberg (normal)"), "fs-dither" },
-    { GIMP_FSLOWBLEED_DITHER, N_("Floyd-Steinberg (reduced color bleeding)"), "fslowbleed-dither" },
-    { GIMP_FIXED_DITHER, N_("Positioned"), "fixed-dither" },
+    { GIMP_NO_DITHER, "GIMP_NO_DITHER", "no-dither" },
+    { GIMP_FS_DITHER, "GIMP_FS_DITHER", "fs-dither" },
+    { GIMP_FSLOWBLEED_DITHER, "GIMP_FSLOWBLEED_DITHER", "fslowbleed-dither" },
+    { GIMP_FIXED_DITHER, "GIMP_FIXED_DITHER", "fixed-dither" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_NO_DITHER, N_("None"), NULL },
+    { GIMP_FS_DITHER, N_("Floyd-Steinberg (normal)"), NULL },
+    { GIMP_FSLOWBLEED_DITHER, N_("Floyd-Steinberg (reduced color bleeding)"), NULL },
+    { GIMP_FIXED_DITHER, N_("Positioned"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpConvertDitherType", values);
+    {
+      type = g_enum_register_static ("GimpConvertDitherType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -153,17 +239,29 @@ gimp_convert_palette_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_MAKE_PALETTE, N_("Generate optimum palette"), "make-palette" },
-    { GIMP_WEB_PALETTE, N_("Use web-optimized palette"), "web-palette" },
-    { GIMP_MONO_PALETTE, N_("Use black and white (1-bit) palette"), "mono-palette" },
-    { GIMP_CUSTOM_PALETTE, N_("Use custom palette"), "custom-palette" },
+    { GIMP_MAKE_PALETTE, "GIMP_MAKE_PALETTE", "make-palette" },
+    { GIMP_WEB_PALETTE, "GIMP_WEB_PALETTE", "web-palette" },
+    { GIMP_MONO_PALETTE, "GIMP_MONO_PALETTE", "mono-palette" },
+    { GIMP_CUSTOM_PALETTE, "GIMP_CUSTOM_PALETTE", "custom-palette" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_MAKE_PALETTE, N_("Generate optimum palette"), NULL },
+    { GIMP_WEB_PALETTE, N_("Use web-optimized palette"), NULL },
+    { GIMP_MONO_PALETTE, N_("Use black and white (1-bit) palette"), NULL },
+    { GIMP_CUSTOM_PALETTE, N_("Use custom palette"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpConvertPaletteType", values);
+    {
+      type = g_enum_register_static ("GimpConvertPaletteType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -186,10 +284,28 @@ gimp_gravity_type_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_GRAVITY_NONE, "GIMP_GRAVITY_NONE", NULL },
+    { GIMP_GRAVITY_NORTH_WEST, "GIMP_GRAVITY_NORTH_WEST", NULL },
+    { GIMP_GRAVITY_NORTH, "GIMP_GRAVITY_NORTH", NULL },
+    { GIMP_GRAVITY_NORTH_EAST, "GIMP_GRAVITY_NORTH_EAST", NULL },
+    { GIMP_GRAVITY_WEST, "GIMP_GRAVITY_WEST", NULL },
+    { GIMP_GRAVITY_CENTER, "GIMP_GRAVITY_CENTER", NULL },
+    { GIMP_GRAVITY_EAST, "GIMP_GRAVITY_EAST", NULL },
+    { GIMP_GRAVITY_SOUTH_WEST, "GIMP_GRAVITY_SOUTH_WEST", NULL },
+    { GIMP_GRAVITY_SOUTH, "GIMP_GRAVITY_SOUTH", NULL },
+    { GIMP_GRAVITY_SOUTH_EAST, "GIMP_GRAVITY_SOUTH_EAST", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpGravityType", values);
+    {
+      type = g_enum_register_static ("GimpGravityType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -199,19 +315,33 @@ gimp_fill_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_FOREGROUND_FILL, N_("Foreground color"), "foreground-fill" },
-    { GIMP_BACKGROUND_FILL, N_("Background color"), "background-fill" },
-    { GIMP_WHITE_FILL, N_("White"), "white-fill" },
-    { GIMP_TRANSPARENT_FILL, N_("Transparency"), "transparent-fill" },
-    { GIMP_PATTERN_FILL, N_("Pattern"), "pattern-fill" },
-    { GIMP_NO_FILL, N_("None"), "no-fill" },
+    { GIMP_FOREGROUND_FILL, "GIMP_FOREGROUND_FILL", "foreground-fill" },
+    { GIMP_BACKGROUND_FILL, "GIMP_BACKGROUND_FILL", "background-fill" },
+    { GIMP_WHITE_FILL, "GIMP_WHITE_FILL", "white-fill" },
+    { GIMP_TRANSPARENT_FILL, "GIMP_TRANSPARENT_FILL", "transparent-fill" },
+    { GIMP_PATTERN_FILL, "GIMP_PATTERN_FILL", "pattern-fill" },
+    { GIMP_NO_FILL, "GIMP_NO_FILL", "no-fill" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_FOREGROUND_FILL, N_("Foreground color"), NULL },
+    { GIMP_BACKGROUND_FILL, N_("Background color"), NULL },
+    { GIMP_WHITE_FILL, N_("White"), NULL },
+    { GIMP_TRANSPARENT_FILL, N_("Transparency"), NULL },
+    { GIMP_PATTERN_FILL, N_("Pattern"), NULL },
+    { GIMP_NO_FILL, N_("None"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpFillType", values);
+    {
+      type = g_enum_register_static ("GimpFillType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -221,24 +351,43 @@ gimp_gradient_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_GRADIENT_LINEAR, N_("Linear"), "linear" },
-    { GIMP_GRADIENT_BILINEAR, N_("Bi-linear"), "bilinear" },
-    { GIMP_GRADIENT_RADIAL, N_("Radial"), "radial" },
-    { GIMP_GRADIENT_SQUARE, N_("Square"), "square" },
-    { GIMP_GRADIENT_CONICAL_SYMMETRIC, N_("Conical (sym)"), "conical-symmetric" },
-    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, N_("Conical (asym)"), "conical-asymmetric" },
-    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, N_("Shaped (angular)"), "shapeburst-angular" },
-    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, N_("Shaped (spherical)"), "shapeburst-spherical" },
-    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, N_("Shaped (dimpled)"), "shapeburst-dimpled" },
-    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, N_("Spiral (cw)"), "spiral-clockwise" },
-    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, N_("Spiral (ccw)"), "spiral-anticlockwise" },
+    { 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_LINEAR, N_("Linear"), NULL },
+    { GIMP_GRADIENT_BILINEAR, N_("Bi-linear"), NULL },
+    { GIMP_GRADIENT_RADIAL, N_("Radial"), NULL },
+    { GIMP_GRADIENT_SQUARE, N_("Square"), NULL },
+    { GIMP_GRADIENT_CONICAL_SYMMETRIC, N_("Conical (sym)"), NULL },
+    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, N_("Conical (asym)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, N_("Shaped (angular)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, N_("Shaped (spherical)"), NULL },
+    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, N_("Shaped (dimpled)"), NULL },
+    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, N_("Spiral (cw)"), NULL },
+    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, N_("Spiral (ccw)"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpGradientType", values);
+    {
+      type = g_enum_register_static ("GimpGradientType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -248,18 +397,31 @@ gimp_grid_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_GRID_DOTS, N_("Intersections (dots)"), "dots" },
-    { GIMP_GRID_INTERSECTIONS, N_("Intersections (crosshairs)"), "intersections" },
-    { GIMP_GRID_ON_OFF_DASH, N_("Dashed"), "on-off-dash" },
-    { GIMP_GRID_DOUBLE_DASH, N_("Double dashed"), "double-dash" },
-    { GIMP_GRID_SOLID, N_("Solid"), "solid" },
+    { GIMP_GRID_DOTS, "GIMP_GRID_DOTS", "dots" },
+    { GIMP_GRID_INTERSECTIONS, "GIMP_GRID_INTERSECTIONS", "intersections" },
+    { GIMP_GRID_ON_OFF_DASH, "GIMP_GRID_ON_OFF_DASH", "on-off-dash" },
+    { GIMP_GRID_DOUBLE_DASH, "GIMP_GRID_DOUBLE_DASH", "double-dash" },
+    { GIMP_GRID_SOLID, "GIMP_GRID_SOLID", "solid" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_GRID_DOTS, N_("Intersections (dots)"), NULL },
+    { GIMP_GRID_INTERSECTIONS, N_("Intersections (crosshairs)"), NULL },
+    { GIMP_GRID_ON_OFF_DASH, N_("Dashed"), NULL },
+    { GIMP_GRID_DOUBLE_DASH, N_("Double dashed"), NULL },
+    { GIMP_GRID_SOLID, N_("Solid"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpGridStyle", values);
+    {
+      type = g_enum_register_static ("GimpGridStyle", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -269,15 +431,25 @@ gimp_stroke_method_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_STROKE_METHOD_LIBART, N_("Stroke line"), "libart" },
-    { GIMP_STROKE_METHOD_PAINT_CORE, N_("Stroke with a paint tool"), "paint-core" },
+    { GIMP_STROKE_METHOD_LIBART, "GIMP_STROKE_METHOD_LIBART", "libart" },
+    { GIMP_STROKE_METHOD_PAINT_CORE, "GIMP_STROKE_METHOD_PAINT_CORE", "paint-core" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_STROKE_METHOD_LIBART, N_("Stroke line"), NULL },
+    { GIMP_STROKE_METHOD_PAINT_CORE, N_("Stroke with a paint tool"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpStrokeMethod", values);
+    {
+      type = g_enum_register_static ("GimpStrokeMethod", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -287,15 +459,25 @@ gimp_stroke_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_STROKE_STYLE_SOLID, N_("Solid"), "solid" },
-    { GIMP_STROKE_STYLE_PATTERN, N_("Pattern"), "pattern" },
+    { GIMP_STROKE_STYLE_SOLID, "GIMP_STROKE_STYLE_SOLID", "solid" },
+    { GIMP_STROKE_STYLE_PATTERN, "GIMP_STROKE_STYLE_PATTERN", "pattern" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_STROKE_STYLE_SOLID, N_("Solid"), NULL },
+    { GIMP_STROKE_STYLE_PATTERN, N_("Pattern"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpStrokeStyle", values);
+    {
+      type = g_enum_register_static ("GimpStrokeStyle", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -305,16 +487,27 @@ gimp_join_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_JOIN_MITER, N_("Miter"), "miter" },
-    { GIMP_JOIN_ROUND, N_("Round"), "round" },
-    { GIMP_JOIN_BEVEL, N_("Bevel"), "bevel" },
+    { GIMP_JOIN_MITER, "GIMP_JOIN_MITER", "miter" },
+    { GIMP_JOIN_ROUND, "GIMP_JOIN_ROUND", "round" },
+    { GIMP_JOIN_BEVEL, "GIMP_JOIN_BEVEL", "bevel" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_JOIN_MITER, N_("Miter"), NULL },
+    { GIMP_JOIN_ROUND, N_("Round"), NULL },
+    { GIMP_JOIN_BEVEL, N_("Bevel"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpJoinStyle", values);
+    {
+      type = g_enum_register_static ("GimpJoinStyle", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -324,16 +517,27 @@ gimp_cap_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CAP_BUTT, N_("Butt"), "butt" },
-    { GIMP_CAP_ROUND, N_("Round"), "round" },
-    { GIMP_CAP_SQUARE, N_("Square"), "square" },
+    { GIMP_CAP_BUTT, "GIMP_CAP_BUTT", "butt" },
+    { GIMP_CAP_ROUND, "GIMP_CAP_ROUND", "round" },
+    { GIMP_CAP_SQUARE, "GIMP_CAP_SQUARE", "square" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CAP_BUTT, N_("Butt"), NULL },
+    { GIMP_CAP_ROUND, N_("Round"), NULL },
+    { GIMP_CAP_SQUARE, N_("Square"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCapStyle", values);
+    {
+      type = g_enum_register_static ("GimpCapStyle", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -343,24 +547,43 @@ gimp_dash_preset_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_DASH_CUSTOM, N_("Custom"), "custom" },
-    { GIMP_DASH_LINE, N_("Line"), "line" },
-    { GIMP_DASH_LONG_DASH, N_("Long dashes"), "long-dash" },
-    { GIMP_DASH_MEDIUM_DASH, N_("Medium dashes"), "medium-dash" },
-    { GIMP_DASH_SHORT_DASH, N_("Short dashes"), "short-dash" },
-    { GIMP_DASH_SPARSE_DOTS, N_("Sparse dots"), "sparse-dots" },
-    { GIMP_DASH_NORMAL_DOTS, N_("Normal dots"), "normal-dots" },
-    { GIMP_DASH_DENSE_DOTS, N_("Dense dots"), "dense-dots" },
-    { GIMP_DASH_STIPPLES, N_("Stipples"), "stipples" },
-    { GIMP_DASH_DASH_DOT, N_("Dash dot..."), "dash-dot" },
-    { GIMP_DASH_DASH_DOT_DOT, N_("Dash dot dot..."), "dash-dot-dot" },
+    { GIMP_DASH_CUSTOM, "GIMP_DASH_CUSTOM", "custom" },
+    { GIMP_DASH_LINE, "GIMP_DASH_LINE", "line" },
+    { GIMP_DASH_LONG_DASH, "GIMP_DASH_LONG_DASH", "long-dash" },
+    { GIMP_DASH_MEDIUM_DASH, "GIMP_DASH_MEDIUM_DASH", "medium-dash" },
+    { GIMP_DASH_SHORT_DASH, "GIMP_DASH_SHORT_DASH", "short-dash" },
+    { GIMP_DASH_SPARSE_DOTS, "GIMP_DASH_SPARSE_DOTS", "sparse-dots" },
+    { GIMP_DASH_NORMAL_DOTS, "GIMP_DASH_NORMAL_DOTS", "normal-dots" },
+    { GIMP_DASH_DENSE_DOTS, "GIMP_DASH_DENSE_DOTS", "dense-dots" },
+    { GIMP_DASH_STIPPLES, "GIMP_DASH_STIPPLES", "stipples" },
+    { GIMP_DASH_DASH_DOT, "GIMP_DASH_DASH_DOT", "dash-dot" },
+    { GIMP_DASH_DASH_DOT_DOT, "GIMP_DASH_DASH_DOT_DOT", "dash-dot-dot" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_DASH_CUSTOM, N_("Custom"), NULL },
+    { GIMP_DASH_LINE, N_("Line"), NULL },
+    { GIMP_DASH_LONG_DASH, N_("Long dashes"), NULL },
+    { GIMP_DASH_MEDIUM_DASH, N_("Medium dashes"), NULL },
+    { GIMP_DASH_SHORT_DASH, N_("Short dashes"), NULL },
+    { GIMP_DASH_SPARSE_DOTS, N_("Sparse dots"), NULL },
+    { GIMP_DASH_NORMAL_DOTS, N_("Normal dots"), NULL },
+    { GIMP_DASH_DENSE_DOTS, N_("Dense dots"), NULL },
+    { GIMP_DASH_STIPPLES, N_("Stipples"), NULL },
+    { GIMP_DASH_DASH_DOT, N_("Dash dot..."), NULL },
+    { GIMP_DASH_DASH_DOT_DOT, N_("Dash dot dot..."), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpDashPreset", values);
+    {
+      type = g_enum_register_static ("GimpDashPreset", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -370,16 +593,27 @@ gimp_icon_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ICON_TYPE_STOCK_ID, N_("Stock ID"), "stock-id" },
-    { GIMP_ICON_TYPE_INLINE_PIXBUF, N_("Inline pixbuf"), "inline-pixbuf" },
-    { GIMP_ICON_TYPE_IMAGE_FILE, N_("Image file"), "image-file" },
+    { GIMP_ICON_TYPE_STOCK_ID, "GIMP_ICON_TYPE_STOCK_ID", "stock-id" },
+    { GIMP_ICON_TYPE_INLINE_PIXBUF, "GIMP_ICON_TYPE_INLINE_PIXBUF", "inline-pixbuf" },
+    { GIMP_ICON_TYPE_IMAGE_FILE, "GIMP_ICON_TYPE_IMAGE_FILE", "image-file" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_ICON_TYPE_STOCK_ID, N_("Stock ID"), NULL },
+    { GIMP_ICON_TYPE_INLINE_PIXBUF, N_("Inline pixbuf"), NULL },
+    { GIMP_ICON_TYPE_IMAGE_FILE, N_("Image file"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpIconType", values);
+    {
+      type = g_enum_register_static ("GimpIconType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -389,16 +623,27 @@ gimp_brush_generated_shape_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_BRUSH_GENERATED_CIRCLE, N_("Circle"), "circle" },
-    { GIMP_BRUSH_GENERATED_SQUARE, N_("Square"), "square" },
-    { GIMP_BRUSH_GENERATED_DIAMOND, N_("Diamond"), "diamond" },
+    { GIMP_BRUSH_GENERATED_CIRCLE, "GIMP_BRUSH_GENERATED_CIRCLE", "circle" },
+    { GIMP_BRUSH_GENERATED_SQUARE, "GIMP_BRUSH_GENERATED_SQUARE", "square" },
+    { GIMP_BRUSH_GENERATED_DIAMOND, "GIMP_BRUSH_GENERATED_DIAMOND", "diamond" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_BRUSH_GENERATED_CIRCLE, N_("Circle"), NULL },
+    { GIMP_BRUSH_GENERATED_SQUARE, N_("Square"), NULL },
+    { GIMP_BRUSH_GENERATED_DIAMOND, N_("Diamond"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpBrushGeneratedShape", values);
+    {
+      type = g_enum_register_static ("GimpBrushGeneratedShape", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -408,16 +653,27 @@ gimp_orientation_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ORIENTATION_HORIZONTAL, N_("Horizontal"), "horizontal" },
-    { GIMP_ORIENTATION_VERTICAL, N_("Vertical"), "vertical" },
-    { GIMP_ORIENTATION_UNKNOWN, N_("Unknown"), "unknown" },
+    { 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_ORIENTATION_HORIZONTAL, N_("Horizontal"), NULL },
+    { GIMP_ORIENTATION_VERTICAL, N_("Vertical"), NULL },
+    { GIMP_ORIENTATION_UNKNOWN, N_("Unknown"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpOrientationType", values);
+    {
+      type = g_enum_register_static ("GimpOrientationType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -433,10 +689,21 @@ gimp_rotation_type_get_type (void)
     { 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 },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpRotationType", values);
+    {
+      type = g_enum_register_static ("GimpRotationType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -446,22 +713,39 @@ gimp_view_size_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_VIEW_SIZE_TINY, N_("Tiny"), "tiny" },
-    { GIMP_VIEW_SIZE_EXTRA_SMALL, N_("Very small"), "extra-small" },
-    { GIMP_VIEW_SIZE_SMALL, N_("Small"), "small" },
-    { GIMP_VIEW_SIZE_MEDIUM, N_("Medium"), "medium" },
-    { GIMP_VIEW_SIZE_LARGE, N_("Large"), "large" },
-    { GIMP_VIEW_SIZE_EXTRA_LARGE, N_("Very large"), "extra-large" },
-    { GIMP_VIEW_SIZE_HUGE, N_("Huge"), "huge" },
-    { GIMP_VIEW_SIZE_ENORMOUS, N_("Enormous"), "enormous" },
-    { GIMP_VIEW_SIZE_GIGANTIC, N_("Gigantic"), "gigantic" },
+    { GIMP_VIEW_SIZE_TINY, "GIMP_VIEW_SIZE_TINY", "tiny" },
+    { GIMP_VIEW_SIZE_EXTRA_SMALL, "GIMP_VIEW_SIZE_EXTRA_SMALL", "extra-small" },
+    { GIMP_VIEW_SIZE_SMALL, "GIMP_VIEW_SIZE_SMALL", "small" },
+    { GIMP_VIEW_SIZE_MEDIUM, "GIMP_VIEW_SIZE_MEDIUM", "medium" },
+    { GIMP_VIEW_SIZE_LARGE, "GIMP_VIEW_SIZE_LARGE", "large" },
+    { GIMP_VIEW_SIZE_EXTRA_LARGE, "GIMP_VIEW_SIZE_EXTRA_LARGE", "extra-large" },
+    { GIMP_VIEW_SIZE_HUGE, "GIMP_VIEW_SIZE_HUGE", "huge" },
+    { GIMP_VIEW_SIZE_ENORMOUS, "GIMP_VIEW_SIZE_ENORMOUS", "enormous" },
+    { GIMP_VIEW_SIZE_GIGANTIC, "GIMP_VIEW_SIZE_GIGANTIC", "gigantic" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_VIEW_SIZE_TINY, N_("Tiny"), NULL },
+    { GIMP_VIEW_SIZE_EXTRA_SMALL, N_("Very small"), NULL },
+    { GIMP_VIEW_SIZE_SMALL, N_("Small"), NULL },
+    { GIMP_VIEW_SIZE_MEDIUM, N_("Medium"), NULL },
+    { GIMP_VIEW_SIZE_LARGE, N_("Large"), NULL },
+    { GIMP_VIEW_SIZE_EXTRA_LARGE, N_("Very large"), NULL },
+    { GIMP_VIEW_SIZE_HUGE, N_("Huge"), NULL },
+    { GIMP_VIEW_SIZE_ENORMOUS, N_("Enormous"), NULL },
+    { GIMP_VIEW_SIZE_GIGANTIC, N_("Gigantic"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpViewSize", values);
+    {
+      type = g_enum_register_static ("GimpViewSize", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -471,16 +755,27 @@ gimp_repeat_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_REPEAT_NONE, N_("None"), "none" },
-    { GIMP_REPEAT_SAWTOOTH, N_("Sawtooth wave"), "sawtooth" },
-    { GIMP_REPEAT_TRIANGULAR, N_("Triangular wave"), "triangular" },
+    { GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
+    { GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
+    { GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_REPEAT_NONE, N_("None"), NULL },
+    { GIMP_REPEAT_SAWTOOTH, N_("Sawtooth wave"), NULL },
+    { GIMP_REPEAT_TRIANGULAR, N_("Triangular wave"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpRepeatMode", values);
+    {
+      type = g_enum_register_static ("GimpRepeatMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -498,10 +793,23 @@ gimp_selection_control_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_SELECTION_OFF, "GIMP_SELECTION_OFF", NULL },
+    { GIMP_SELECTION_LAYER_OFF, "GIMP_SELECTION_LAYER_OFF", NULL },
+    { GIMP_SELECTION_ON, "GIMP_SELECTION_ON", NULL },
+    { GIMP_SELECTION_PAUSE, "GIMP_SELECTION_PAUSE", NULL },
+    { GIMP_SELECTION_RESUME, "GIMP_SELECTION_RESUME", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpSelectionControl", values);
+    {
+      type = g_enum_register_static ("GimpSelectionControl", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -511,16 +819,27 @@ gimp_thumbnail_size_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_THUMBNAIL_SIZE_NONE, N_("No thumbnails"), "none" },
-    { GIMP_THUMBNAIL_SIZE_NORMAL, N_("Normal (128x128)"), "normal" },
-    { GIMP_THUMBNAIL_SIZE_LARGE, N_("Large (256x256)"), "large" },
+    { GIMP_THUMBNAIL_SIZE_NONE, "GIMP_THUMBNAIL_SIZE_NONE", "none" },
+    { GIMP_THUMBNAIL_SIZE_NORMAL, "GIMP_THUMBNAIL_SIZE_NORMAL", "normal" },
+    { GIMP_THUMBNAIL_SIZE_LARGE, "GIMP_THUMBNAIL_SIZE_LARGE", "large" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_THUMBNAIL_SIZE_NONE, N_("No thumbnails"), NULL },
+    { GIMP_THUMBNAIL_SIZE_NORMAL, N_("Normal (128x128)"), NULL },
+    { GIMP_THUMBNAIL_SIZE_LARGE, N_("Large (256x256)"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpThumbnailSize", values);
+    {
+      type = g_enum_register_static ("GimpThumbnailSize", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -530,15 +849,25 @@ gimp_transform_direction_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_FORWARD, N_("Forward (traditional)"), "forward" },
-    { GIMP_TRANSFORM_BACKWARD, N_("Backward (corrective)"), "backward" },
+    { GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
+    { GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TRANSFORM_FORWARD, N_("Forward (traditional)"), NULL },
+    { GIMP_TRANSFORM_BACKWARD, N_("Backward (corrective)"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTransformDirection", values);
+    {
+      type = g_enum_register_static ("GimpTransformDirection", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -553,10 +882,20 @@ gimp_undo_mode_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", NULL },
+    { GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpUndoMode", values);
+    {
+      type = g_enum_register_static ("GimpUndoMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -577,10 +916,26 @@ gimp_undo_event_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_UNDO_EVENT_UNDO_PUSHED, "GIMP_UNDO_EVENT_UNDO_PUSHED", NULL },
+    { GIMP_UNDO_EVENT_UNDO_EXPIRED, "GIMP_UNDO_EVENT_UNDO_EXPIRED", NULL },
+    { GIMP_UNDO_EVENT_REDO_EXPIRED, "GIMP_UNDO_EVENT_REDO_EXPIRED", NULL },
+    { GIMP_UNDO_EVENT_UNDO, "GIMP_UNDO_EVENT_UNDO", NULL },
+    { GIMP_UNDO_EVENT_REDO, "GIMP_UNDO_EVENT_REDO", NULL },
+    { GIMP_UNDO_EVENT_UNDO_FREE, "GIMP_UNDO_EVENT_UNDO_FREE", NULL },
+    { GIMP_UNDO_EVENT_UNDO_FREEZE, "GIMP_UNDO_EVENT_UNDO_FREEZE", NULL },
+    { GIMP_UNDO_EVENT_UNDO_THAW, "GIMP_UNDO_EVENT_UNDO_THAW", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpUndoEvent", values);
+    {
+      type = g_enum_register_static ("GimpUndoEvent", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -590,88 +945,171 @@ gimp_undo_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_UNDO_GROUP_NONE, N_("<<invalid>>"), "group-none" },
-    { GIMP_UNDO_GROUP_IMAGE_SCALE, N_("Scale image"), "group-image-scale" },
-    { GIMP_UNDO_GROUP_IMAGE_RESIZE, N_("Resize image"), "group-image-resize" },
-    { GIMP_UNDO_GROUP_IMAGE_FLIP, N_("Flip image"), "group-image-flip" },
-    { GIMP_UNDO_GROUP_IMAGE_ROTATE, N_("Rotate image"), "group-image-rotate" },
-    { GIMP_UNDO_GROUP_IMAGE_CROP, N_("Crop image"), "group-image-crop" },
-    { GIMP_UNDO_GROUP_IMAGE_CONVERT, N_("Convert image"), "group-image-convert" },
-    { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, N_("Merge layers"), "group-image-layers-merge" },
-    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge vectors"), "group-image-vectors-merge" },
-    { GIMP_UNDO_GROUP_IMAGE_QMASK, N_("Quick Mask"), "group-image-qmask" },
-    { GIMP_UNDO_GROUP_IMAGE_GRID, N_("Grid"), "group-image-grid" },
-    { GIMP_UNDO_GROUP_IMAGE_GUIDE, N_("Guide"), "group-image-guide" },
-    { GIMP_UNDO_GROUP_DRAWABLE, N_("Drawable"), "group-drawable" },
-    { GIMP_UNDO_GROUP_DRAWABLE_MOD, N_("Drawable mod"), "group-drawable-mod" },
-    { GIMP_UNDO_GROUP_MASK, N_("Selection mask"), "group-mask" },
-    { GIMP_UNDO_GROUP_ITEM_VISIBILITY, N_("Item visibility"), "group-item-visibility" },
-    { GIMP_UNDO_GROUP_ITEM_LINKED, N_("Linked item"), "group-item-linked" },
-    { GIMP_UNDO_GROUP_ITEM_PROPERTIES, N_("Item properties"), "group-item-properties" },
-    { GIMP_UNDO_GROUP_ITEM_DISPLACE, N_("Move item"), "group-item-displace" },
-    { GIMP_UNDO_GROUP_ITEM_SCALE, N_("Scale item"), "group-item-scale" },
-    { GIMP_UNDO_GROUP_ITEM_RESIZE, N_("Resize item"), "group-item-resize" },
-    { GIMP_UNDO_GROUP_LAYER_ADD_MASK, N_("Add layer mask"), "group-layer-add-mask" },
-    { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, N_("Apply layer mask"), "group-layer-apply-mask" },
-    { GIMP_UNDO_GROUP_FS_TO_LAYER, N_("Floating selection to layer"), "group-fs-to-layer" },
-    { GIMP_UNDO_GROUP_FS_FLOAT, N_("Float selection"), "group-fs-float" },
-    { GIMP_UNDO_GROUP_FS_ANCHOR, N_("Anchor floating selection"), "group-fs-anchor" },
-    { GIMP_UNDO_GROUP_FS_REMOVE, N_("Remove floating selection"), "group-fs-remove" },
-    { GIMP_UNDO_GROUP_EDIT_PASTE, N_("Paste"), "group-edit-paste" },
-    { GIMP_UNDO_GROUP_EDIT_CUT, N_("Cut"), "group-edit-cut" },
-    { GIMP_UNDO_GROUP_TEXT, N_("Text"), "group-text" },
-    { GIMP_UNDO_GROUP_TRANSFORM, N_("Transform"), "group-transform" },
-    { GIMP_UNDO_GROUP_PAINT, N_("Paint"), "group-paint" },
-    { GIMP_UNDO_GROUP_PARASITE_ATTACH, N_("Attach parasite"), "group-parasite-attach" },
-    { GIMP_UNDO_GROUP_PARASITE_REMOVE, N_("Remove parasite"), "group-parasite-remove" },
-    { GIMP_UNDO_GROUP_VECTORS_IMPORT, N_("Import paths"), "group-vectors-import" },
-    { GIMP_UNDO_GROUP_MISC, N_("Plug-In"), "group-misc" },
-    { GIMP_UNDO_IMAGE_TYPE, N_("Image type"), "image-type" },
-    { GIMP_UNDO_IMAGE_SIZE, N_("Image size"), "image-size" },
-    { GIMP_UNDO_IMAGE_RESOLUTION, N_("Resolution change"), "image-resolution" },
-    { GIMP_UNDO_IMAGE_GRID, N_("Grid"), "image-grid" },
-    { GIMP_UNDO_IMAGE_GUIDE, N_("Guide"), "image-guide" },
-    { GIMP_UNDO_IMAGE_COLORMAP, N_("Change indexed palette"), "image-colormap" },
-    { GIMP_UNDO_DRAWABLE, N_("Drawable"), "drawable" },
-    { GIMP_UNDO_DRAWABLE_MOD, N_("Drawable mod"), "drawable-mod" },
-    { GIMP_UNDO_MASK, N_("Selection mask"), "mask" },
-    { GIMP_UNDO_ITEM_RENAME, N_("Rename item"), "item-rename" },
-    { GIMP_UNDO_ITEM_DISPLACE, N_("Move item"), "item-displace" },
-    { GIMP_UNDO_ITEM_VISIBILITY, N_("Item visibility"), "item-visibility" },
-    { GIMP_UNDO_ITEM_LINKED, N_("Set item linked"), "item-linked" },
-    { GIMP_UNDO_LAYER_ADD, N_("New layer"), "layer-add" },
-    { GIMP_UNDO_LAYER_REMOVE, N_("Delete layer"), "layer-remove" },
-    { GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), "layer-mask-add" },
-    { GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), "layer-mask-remove" },
-    { GIMP_UNDO_LAYER_REPOSITION, N_("Reposition layer"), "layer-reposition" },
-    { GIMP_UNDO_LAYER_MODE, N_("Set layer mode"), "layer-mode" },
-    { GIMP_UNDO_LAYER_OPACITY, N_("Set layer opacity"), "layer-opacity" },
-    { GIMP_UNDO_LAYER_PRESERVE_TRANS, N_("Set preserve trans"), "layer-preserve-trans" },
-    { GIMP_UNDO_TEXT_LAYER, N_("Text"), "text-layer" },
-    { GIMP_UNDO_TEXT_LAYER_MODIFIED, N_("Text modified"), "text-layer-modified" },
-    { GIMP_UNDO_CHANNEL_ADD, N_("New channel"), "channel-add" },
-    { GIMP_UNDO_CHANNEL_REMOVE, N_("Delete channel"), "channel-remove" },
-    { GIMP_UNDO_CHANNEL_REPOSITION, N_("Reposition channel"), "channel-reposition" },
-    { GIMP_UNDO_CHANNEL_COLOR, N_("Channel color"), "channel-color" },
-    { GIMP_UNDO_VECTORS_ADD, N_("New vectors"), "vectors-add" },
-    { GIMP_UNDO_VECTORS_REMOVE, N_("Delete vectors"), "vectors-remove" },
-    { GIMP_UNDO_VECTORS_MOD, N_("Vectors mod"), "vectors-mod" },
-    { GIMP_UNDO_VECTORS_REPOSITION, N_("Reposition vectors"), "vectors-reposition" },
-    { GIMP_UNDO_FS_TO_LAYER, N_("FS to layer"), "fs-to-layer" },
-    { GIMP_UNDO_FS_RIGOR, N_("FS rigor"), "fs-rigor" },
-    { GIMP_UNDO_FS_RELAX, N_("FS relax"), "fs-relax" },
-    { GIMP_UNDO_TRANSFORM, N_("Transform"), "transform" },
-    { GIMP_UNDO_PAINT, N_("Paint"), "paint" },
-    { GIMP_UNDO_PARASITE_ATTACH, N_("Attach parasite"), "parasite-attach" },
-    { GIMP_UNDO_PARASITE_REMOVE, N_("Remove parasite"), "parasite-remove" },
-    { GIMP_UNDO_CANT, N_("EEK: can't undo"), "cant" },
+    { GIMP_UNDO_GROUP_NONE, "GIMP_UNDO_GROUP_NONE", "group-none" },
+    { GIMP_UNDO_GROUP_IMAGE_SCALE, "GIMP_UNDO_GROUP_IMAGE_SCALE", "group-image-scale" },
+    { GIMP_UNDO_GROUP_IMAGE_RESIZE, "GIMP_UNDO_GROUP_IMAGE_RESIZE", "group-image-resize" },
+    { GIMP_UNDO_GROUP_IMAGE_FLIP, "GIMP_UNDO_GROUP_IMAGE_FLIP", "group-image-flip" },
+    { GIMP_UNDO_GROUP_IMAGE_ROTATE, "GIMP_UNDO_GROUP_IMAGE_ROTATE", "group-image-rotate" },
+    { GIMP_UNDO_GROUP_IMAGE_CROP, "GIMP_UNDO_GROUP_IMAGE_CROP", "group-image-crop" },
+    { GIMP_UNDO_GROUP_IMAGE_CONVERT, "GIMP_UNDO_GROUP_IMAGE_CONVERT", "group-image-convert" },
+    { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, "GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" },
+    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, "GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" },
+    { GIMP_UNDO_GROUP_IMAGE_QMASK, "GIMP_UNDO_GROUP_IMAGE_QMASK", "group-image-qmask" },
+    { GIMP_UNDO_GROUP_IMAGE_GRID, "GIMP_UNDO_GROUP_IMAGE_GRID", "group-image-grid" },
+    { GIMP_UNDO_GROUP_IMAGE_GUIDE, "GIMP_UNDO_GROUP_IMAGE_GUIDE", "group-image-guide" },
+    { GIMP_UNDO_GROUP_DRAWABLE, "GIMP_UNDO_GROUP_DRAWABLE", "group-drawable" },
+    { GIMP_UNDO_GROUP_DRAWABLE_MOD, "GIMP_UNDO_GROUP_DRAWABLE_MOD", "group-drawable-mod" },
+    { GIMP_UNDO_GROUP_MASK, "GIMP_UNDO_GROUP_MASK", "group-mask" },
+    { GIMP_UNDO_GROUP_ITEM_VISIBILITY, "GIMP_UNDO_GROUP_ITEM_VISIBILITY", "group-item-visibility" },
+    { GIMP_UNDO_GROUP_ITEM_LINKED, "GIMP_UNDO_GROUP_ITEM_LINKED", "group-item-linked" },
+    { GIMP_UNDO_GROUP_ITEM_PROPERTIES, "GIMP_UNDO_GROUP_ITEM_PROPERTIES", "group-item-properties" },
+    { GIMP_UNDO_GROUP_ITEM_DISPLACE, "GIMP_UNDO_GROUP_ITEM_DISPLACE", "group-item-displace" },
+    { GIMP_UNDO_GROUP_ITEM_SCALE, "GIMP_UNDO_GROUP_ITEM_SCALE", "group-item-scale" },
+    { GIMP_UNDO_GROUP_ITEM_RESIZE, "GIMP_UNDO_GROUP_ITEM_RESIZE", "group-item-resize" },
+    { GIMP_UNDO_GROUP_LAYER_ADD_MASK, "GIMP_UNDO_GROUP_LAYER_ADD_MASK", "group-layer-add-mask" },
+    { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, "GIMP_UNDO_GROUP_LAYER_APPLY_MASK", "group-layer-apply-mask" },
+    { GIMP_UNDO_GROUP_FS_TO_LAYER, "GIMP_UNDO_GROUP_FS_TO_LAYER", "group-fs-to-layer" },
+    { GIMP_UNDO_GROUP_FS_FLOAT, "GIMP_UNDO_GROUP_FS_FLOAT", "group-fs-float" },
+    { GIMP_UNDO_GROUP_FS_ANCHOR, "GIMP_UNDO_GROUP_FS_ANCHOR", "group-fs-anchor" },
+    { GIMP_UNDO_GROUP_FS_REMOVE, "GIMP_UNDO_GROUP_FS_REMOVE", "group-fs-remove" },
+    { GIMP_UNDO_GROUP_EDIT_PASTE, "GIMP_UNDO_GROUP_EDIT_PASTE", "group-edit-paste" },
+    { GIMP_UNDO_GROUP_EDIT_CUT, "GIMP_UNDO_GROUP_EDIT_CUT", "group-edit-cut" },
+    { GIMP_UNDO_GROUP_TEXT, "GIMP_UNDO_GROUP_TEXT", "group-text" },
+    { GIMP_UNDO_GROUP_TRANSFORM, "GIMP_UNDO_GROUP_TRANSFORM", "group-transform" },
+    { GIMP_UNDO_GROUP_PAINT, "GIMP_UNDO_GROUP_PAINT", "group-paint" },
+    { GIMP_UNDO_GROUP_PARASITE_ATTACH, "GIMP_UNDO_GROUP_PARASITE_ATTACH", "group-parasite-attach" },
+    { GIMP_UNDO_GROUP_PARASITE_REMOVE, "GIMP_UNDO_GROUP_PARASITE_REMOVE", "group-parasite-remove" },
+    { GIMP_UNDO_GROUP_VECTORS_IMPORT, "GIMP_UNDO_GROUP_VECTORS_IMPORT", "group-vectors-import" },
+    { GIMP_UNDO_GROUP_MISC, "GIMP_UNDO_GROUP_MISC", "group-misc" },
+    { GIMP_UNDO_IMAGE_TYPE, "GIMP_UNDO_IMAGE_TYPE", "image-type" },
+    { GIMP_UNDO_IMAGE_SIZE, "GIMP_UNDO_IMAGE_SIZE", "image-size" },
+    { GIMP_UNDO_IMAGE_RESOLUTION, "GIMP_UNDO_IMAGE_RESOLUTION", "image-resolution" },
+    { GIMP_UNDO_IMAGE_GRID, "GIMP_UNDO_IMAGE_GRID", "image-grid" },
+    { GIMP_UNDO_IMAGE_GUIDE, "GIMP_UNDO_IMAGE_GUIDE", "image-guide" },
+    { GIMP_UNDO_IMAGE_COLORMAP, "GIMP_UNDO_IMAGE_COLORMAP", "image-colormap" },
+    { GIMP_UNDO_DRAWABLE, "GIMP_UNDO_DRAWABLE", "drawable" },
+    { GIMP_UNDO_DRAWABLE_MOD, "GIMP_UNDO_DRAWABLE_MOD", "drawable-mod" },
+    { GIMP_UNDO_MASK, "GIMP_UNDO_MASK", "mask" },
+    { GIMP_UNDO_ITEM_RENAME, "GIMP_UNDO_ITEM_RENAME", "item-rename" },
+    { GIMP_UNDO_ITEM_DISPLACE, "GIMP_UNDO_ITEM_DISPLACE", "item-displace" },
+    { GIMP_UNDO_ITEM_VISIBILITY, "GIMP_UNDO_ITEM_VISIBILITY", "item-visibility" },
+    { GIMP_UNDO_ITEM_LINKED, "GIMP_UNDO_ITEM_LINKED", "item-linked" },
+    { GIMP_UNDO_LAYER_ADD, "GIMP_UNDO_LAYER_ADD", "layer-add" },
+    { GIMP_UNDO_LAYER_REMOVE, "GIMP_UNDO_LAYER_REMOVE", "layer-remove" },
+    { GIMP_UNDO_LAYER_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
+    { GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
+    { GIMP_UNDO_LAYER_REPOSITION, "GIMP_UNDO_LAYER_REPOSITION", "layer-reposition" },
+    { GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
+    { GIMP_UNDO_LAYER_OPACITY, "GIMP_UNDO_LAYER_OPACITY", "layer-opacity" },
+    { GIMP_UNDO_LAYER_PRESERVE_TRANS, "GIMP_UNDO_LAYER_PRESERVE_TRANS", "layer-preserve-trans" },
+    { GIMP_UNDO_TEXT_LAYER, "GIMP_UNDO_TEXT_LAYER", "text-layer" },
+    { GIMP_UNDO_TEXT_LAYER_MODIFIED, "GIMP_UNDO_TEXT_LAYER_MODIFIED", "text-layer-modified" },
+    { GIMP_UNDO_CHANNEL_ADD, "GIMP_UNDO_CHANNEL_ADD", "channel-add" },
+    { GIMP_UNDO_CHANNEL_REMOVE, "GIMP_UNDO_CHANNEL_REMOVE", "channel-remove" },
+    { GIMP_UNDO_CHANNEL_REPOSITION, "GIMP_UNDO_CHANNEL_REPOSITION", "channel-reposition" },
+    { GIMP_UNDO_CHANNEL_COLOR, "GIMP_UNDO_CHANNEL_COLOR", "channel-color" },
+    { GIMP_UNDO_VECTORS_ADD, "GIMP_UNDO_VECTORS_ADD", "vectors-add" },
+    { GIMP_UNDO_VECTORS_REMOVE, "GIMP_UNDO_VECTORS_REMOVE", "vectors-remove" },
+    { GIMP_UNDO_VECTORS_MOD, "GIMP_UNDO_VECTORS_MOD", "vectors-mod" },
+    { GIMP_UNDO_VECTORS_REPOSITION, "GIMP_UNDO_VECTORS_REPOSITION", "vectors-reposition" },
+    { GIMP_UNDO_FS_TO_LAYER, "GIMP_UNDO_FS_TO_LAYER", "fs-to-layer" },
+    { GIMP_UNDO_FS_RIGOR, "GIMP_UNDO_FS_RIGOR", "fs-rigor" },
+    { GIMP_UNDO_FS_RELAX, "GIMP_UNDO_FS_RELAX", "fs-relax" },
+    { GIMP_UNDO_TRANSFORM, "GIMP_UNDO_TRANSFORM", "transform" },
+    { GIMP_UNDO_PAINT, "GIMP_UNDO_PAINT", "paint" },
+    { GIMP_UNDO_PARASITE_ATTACH, "GIMP_UNDO_PARASITE_ATTACH", "parasite-attach" },
+    { GIMP_UNDO_PARASITE_REMOVE, "GIMP_UNDO_PARASITE_REMOVE", "parasite-remove" },
+    { GIMP_UNDO_CANT, "GIMP_UNDO_CANT", "cant" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_UNDO_GROUP_NONE, N_("<<invalid>>"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_SCALE, N_("Scale image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_RESIZE, N_("Resize image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_FLIP, N_("Flip image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_ROTATE, N_("Rotate image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_CROP, N_("Crop image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_CONVERT, N_("Convert image"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, N_("Merge layers"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge vectors"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_QMASK, N_("Quick Mask"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_GRID, N_("Grid"), NULL },
+    { GIMP_UNDO_GROUP_IMAGE_GUIDE, N_("Guide"), NULL },
+    { GIMP_UNDO_GROUP_DRAWABLE, N_("Drawable"), NULL },
+    { GIMP_UNDO_GROUP_DRAWABLE_MOD, N_("Drawable mod"), NULL },
+    { GIMP_UNDO_GROUP_MASK, N_("Selection mask"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_VISIBILITY, N_("Item visibility"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_LINKED, N_("Linked item"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_PROPERTIES, N_("Item properties"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_DISPLACE, N_("Move item"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_SCALE, N_("Scale item"), NULL },
+    { GIMP_UNDO_GROUP_ITEM_RESIZE, N_("Resize item"), NULL },
+    { GIMP_UNDO_GROUP_LAYER_ADD_MASK, N_("Add layer mask"), NULL },
+    { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, N_("Apply layer mask"), NULL },
+    { GIMP_UNDO_GROUP_FS_TO_LAYER, N_("Floating selection to layer"), NULL },
+    { GIMP_UNDO_GROUP_FS_FLOAT, N_("Float selection"), NULL },
+    { GIMP_UNDO_GROUP_FS_ANCHOR, N_("Anchor floating selection"), NULL },
+    { GIMP_UNDO_GROUP_FS_REMOVE, N_("Remove floating selection"), NULL },
+    { GIMP_UNDO_GROUP_EDIT_PASTE, N_("Paste"), NULL },
+    { GIMP_UNDO_GROUP_EDIT_CUT, N_("Cut"), NULL },
+    { GIMP_UNDO_GROUP_TEXT, N_("Text"), NULL },
+    { GIMP_UNDO_GROUP_TRANSFORM, N_("Transform"), NULL },
+    { GIMP_UNDO_GROUP_PAINT, N_("Paint"), NULL },
+    { GIMP_UNDO_GROUP_PARASITE_ATTACH, N_("Attach parasite"), NULL },
+    { GIMP_UNDO_GROUP_PARASITE_REMOVE, N_("Remove parasite"), NULL },
+    { GIMP_UNDO_GROUP_VECTORS_IMPORT, N_("Import paths"), NULL },
+    { GIMP_UNDO_GROUP_MISC, N_("Plug-In"), NULL },
+    { GIMP_UNDO_IMAGE_TYPE, N_("Image type"), NULL },
+    { GIMP_UNDO_IMAGE_SIZE, N_("Image size"), NULL },
+    { GIMP_UNDO_IMAGE_RESOLUTION, N_("Resolution change"), NULL },
+    { GIMP_UNDO_IMAGE_GRID, N_("Grid"), NULL },
+    { GIMP_UNDO_IMAGE_GUIDE, N_("Guide"), NULL },
+    { GIMP_UNDO_IMAGE_COLORMAP, N_("Change indexed palette"), NULL },
+    { GIMP_UNDO_DRAWABLE, N_("Drawable"), NULL },
+    { GIMP_UNDO_DRAWABLE_MOD, N_("Drawable mod"), NULL },
+    { GIMP_UNDO_MASK, N_("Selection mask"), NULL },
+    { GIMP_UNDO_ITEM_RENAME, N_("Rename item"), NULL },
+    { GIMP_UNDO_ITEM_DISPLACE, N_("Move item"), NULL },
+    { GIMP_UNDO_ITEM_VISIBILITY, N_("Item visibility"), NULL },
+    { GIMP_UNDO_ITEM_LINKED, N_("Set item linked"), NULL },
+    { GIMP_UNDO_LAYER_ADD, N_("New layer"), NULL },
+    { GIMP_UNDO_LAYER_REMOVE, N_("Delete layer"), NULL },
+    { GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), NULL },
+    { GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), NULL },
+    { GIMP_UNDO_LAYER_REPOSITION, N_("Reposition layer"), NULL },
+    { GIMP_UNDO_LAYER_MODE, N_("Set layer mode"), NULL },
+    { GIMP_UNDO_LAYER_OPACITY, N_("Set layer opacity"), NULL },
+    { GIMP_UNDO_LAYER_PRESERVE_TRANS, N_("Set preserve trans"), NULL },
+    { GIMP_UNDO_TEXT_LAYER, N_("Text"), NULL },
+    { GIMP_UNDO_TEXT_LAYER_MODIFIED, N_("Text modified"), NULL },
+    { GIMP_UNDO_CHANNEL_ADD, N_("New channel"), NULL },
+    { GIMP_UNDO_CHANNEL_REMOVE, N_("Delete channel"), NULL },
+    { GIMP_UNDO_CHANNEL_REPOSITION, N_("Reposition channel"), NULL },
+    { GIMP_UNDO_CHANNEL_COLOR, N_("Channel color"), NULL },
+    { GIMP_UNDO_VECTORS_ADD, N_("New vectors"), NULL },
+    { GIMP_UNDO_VECTORS_REMOVE, N_("Delete vectors"), NULL },
+    { GIMP_UNDO_VECTORS_MOD, N_("Vectors mod"), NULL },
+    { GIMP_UNDO_VECTORS_REPOSITION, N_("Reposition vectors"), NULL },
+    { GIMP_UNDO_FS_TO_LAYER, N_("FS to layer"), NULL },
+    { GIMP_UNDO_FS_RIGOR, N_("FS rigor"), NULL },
+    { GIMP_UNDO_FS_RELAX, N_("FS relax"), NULL },
+    { GIMP_UNDO_TRANSFORM, N_("Transform"), NULL },
+    { GIMP_UNDO_PAINT, N_("Paint"), NULL },
+    { GIMP_UNDO_PARASITE_ATTACH, N_("Attach parasite"), NULL },
+    { GIMP_UNDO_PARASITE_REMOVE, N_("Remove parasite"), NULL },
+    { GIMP_UNDO_CANT, N_("EEK: can't undo"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpUndoType", values);
+    {
+      type = g_enum_register_static ("GimpUndoType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -695,10 +1133,29 @@ gimp_dirty_mask_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpFlagsDesc descs[] =
+  {
+    { GIMP_DIRTY_NONE, "GIMP_DIRTY_NONE", NULL },
+    { GIMP_DIRTY_IMAGE, "GIMP_DIRTY_IMAGE", NULL },
+    { GIMP_DIRTY_IMAGE_SIZE, "GIMP_DIRTY_IMAGE_SIZE", NULL },
+    { GIMP_DIRTY_IMAGE_META, "GIMP_DIRTY_IMAGE_META", NULL },
+    { GIMP_DIRTY_IMAGE_STRUCTURE, "GIMP_DIRTY_IMAGE_STRUCTURE", NULL },
+    { GIMP_DIRTY_ITEM, "GIMP_DIRTY_ITEM", NULL },
+    { GIMP_DIRTY_ITEM_META, "GIMP_DIRTY_ITEM_META", NULL },
+    { GIMP_DIRTY_DRAWABLE, "GIMP_DIRTY_DRAWABLE", NULL },
+    { GIMP_DIRTY_VECTORS, "GIMP_DIRTY_VECTORS", NULL },
+    { GIMP_DIRTY_SELECTION, "GIMP_DIRTY_SELECTION", NULL },
+    { GIMP_DIRTY_ALL, "GIMP_DIRTY_ALL", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_flags_register_static ("GimpDirtyMask", values);
+    {
+      type = g_flags_register_static ("GimpDirtyMask", values);
+      gimp_flags_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/display/Makefile.am b/app/display/Makefile.am
index 03632fa5d9..446ffd6559 100644
--- a/app/display/Makefile.am
+++ b/app/display/Makefile.am
@@ -86,11 +86,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/display-enums.c: $(srcdir)/display-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"display-enums.h\"\n#include\"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"display-enums.h\"\n#include\"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/display-enums.h > xgen-dec \
 	&& cp xgen-dec $(@F) \
 	&& rm -f xgen-dec
diff --git a/app/display/display-enums.c b/app/display/display-enums.c
index 446f1b905a..6ca988186b 100644
--- a/app/display/display-enums.c
+++ b/app/display/display-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "display-enums.h"
 #include"gimp-intl.h"
 
@@ -12,16 +13,27 @@ gimp_cursor_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CURSOR_MODE_TOOL_ICON, N_("Tool icon"), "tool-icon" },
-    { GIMP_CURSOR_MODE_TOOL_CROSSHAIR, N_("Tool icon with crosshair"), "tool-crosshair" },
-    { GIMP_CURSOR_MODE_CROSSHAIR, N_("Crosshair only"), "crosshair" },
+    { GIMP_CURSOR_MODE_TOOL_ICON, "GIMP_CURSOR_MODE_TOOL_ICON", "tool-icon" },
+    { GIMP_CURSOR_MODE_TOOL_CROSSHAIR, "GIMP_CURSOR_MODE_TOOL_CROSSHAIR", "tool-crosshair" },
+    { GIMP_CURSOR_MODE_CROSSHAIR, "GIMP_CURSOR_MODE_CROSSHAIR", "crosshair" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CURSOR_MODE_TOOL_ICON, N_("Tool icon"), NULL },
+    { GIMP_CURSOR_MODE_TOOL_CROSSHAIR, N_("Tool icon with crosshair"), NULL },
+    { GIMP_CURSOR_MODE_CROSSHAIR, N_("Crosshair only"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCursorMode", values);
+    {
+      type = g_enum_register_static ("GimpCursorMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -31,17 +43,29 @@ gimp_canvas_padding_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CANVAS_PADDING_MODE_DEFAULT, N_("From theme"), "default" },
-    { GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, N_("Light check color"), "light-check" },
-    { GIMP_CANVAS_PADDING_MODE_DARK_CHECK, N_("Dark check color"), "dark-check" },
-    { GIMP_CANVAS_PADDING_MODE_CUSTOM, N_("Custom color"), "custom" },
+    { GIMP_CANVAS_PADDING_MODE_DEFAULT, "GIMP_CANVAS_PADDING_MODE_DEFAULT", "default" },
+    { GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, "GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK", "light-check" },
+    { GIMP_CANVAS_PADDING_MODE_DARK_CHECK, "GIMP_CANVAS_PADDING_MODE_DARK_CHECK", "dark-check" },
+    { GIMP_CANVAS_PADDING_MODE_CUSTOM, "GIMP_CANVAS_PADDING_MODE_CUSTOM", "custom" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CANVAS_PADDING_MODE_DEFAULT, N_("From theme"), NULL },
+    { GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, N_("Light check color"), NULL },
+    { GIMP_CANVAS_PADDING_MODE_DARK_CHECK, N_("Dark check color"), NULL },
+    { GIMP_CANVAS_PADDING_MODE_CUSTOM, N_("Custom color"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCanvasPaddingMode", values);
+    {
+      type = g_enum_register_static ("GimpCanvasPaddingMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/paint/Makefile.am b/app/paint/Makefile.am
index 3a4534e8ea..f6c284eaee 100644
--- a/app/paint/Makefile.am
+++ b/app/paint/Makefile.am
@@ -83,11 +83,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/paint-enums.c: $(srcdir)/paint-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"paint-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"paint-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/paint-enums.h > xgen-pec \
 	&& cp xgen-pec $(@F) \
 	&& rm -f xgen-pec
diff --git a/app/paint/paint-enums.c b/app/paint/paint-enums.c
index 0fea969cee..689e76eaed 100644
--- a/app/paint/paint-enums.c
+++ b/app/paint/paint-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "paint-enums.h"
 #include "gimp-intl.h"
 
@@ -12,15 +13,25 @@ gimp_clone_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_IMAGE_CLONE, N_("Image source"), "image-clone" },
-    { GIMP_PATTERN_CLONE, N_("Pattern source"), "pattern-clone" },
+    { GIMP_IMAGE_CLONE, "GIMP_IMAGE_CLONE", "image-clone" },
+    { GIMP_PATTERN_CLONE, "GIMP_PATTERN_CLONE", "pattern-clone" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_IMAGE_CLONE, N_("Image source"), NULL },
+    { GIMP_PATTERN_CLONE, N_("Pattern source"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCloneType", values);
+    {
+      type = g_enum_register_static ("GimpCloneType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -30,16 +41,27 @@ gimp_clone_align_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CLONE_ALIGN_NO, N_("Non-aligned"), "no" },
-    { GIMP_CLONE_ALIGN_YES, N_("Aligned"), "yes" },
-    { GIMP_CLONE_ALIGN_REGISTERED, N_("Registered"), "registered" },
+    { GIMP_CLONE_ALIGN_NO, "GIMP_CLONE_ALIGN_NO", "no" },
+    { GIMP_CLONE_ALIGN_YES, "GIMP_CLONE_ALIGN_YES", "yes" },
+    { GIMP_CLONE_ALIGN_REGISTERED, "GIMP_CLONE_ALIGN_REGISTERED", "registered" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CLONE_ALIGN_NO, N_("Non-aligned"), NULL },
+    { GIMP_CLONE_ALIGN_YES, N_("Aligned"), NULL },
+    { GIMP_CLONE_ALIGN_REGISTERED, N_("Registered"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCloneAlignMode", values);
+    {
+      type = g_enum_register_static ("GimpCloneAlignMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -49,15 +71,25 @@ gimp_dodge_burn_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_DODGE, N_("Dodge"), "dodge" },
-    { GIMP_BURN, N_("Burn"), "burn" },
+    { GIMP_DODGE, "GIMP_DODGE", "dodge" },
+    { GIMP_BURN, "GIMP_BURN", "burn" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_DODGE, N_("Dodge"), NULL },
+    { GIMP_BURN, N_("Burn"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpDodgeBurnType", values);
+    {
+      type = g_enum_register_static ("GimpDodgeBurnType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -67,15 +99,25 @@ gimp_convolve_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_BLUR_CONVOLVE, N_("Blur"), "blur-convolve" },
-    { GIMP_SHARPEN_CONVOLVE, N_("Sharpen"), "sharpen-convolve" },
+    { GIMP_BLUR_CONVOLVE, "GIMP_BLUR_CONVOLVE", "blur-convolve" },
+    { GIMP_SHARPEN_CONVOLVE, "GIMP_SHARPEN_CONVOLVE", "sharpen-convolve" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_BLUR_CONVOLVE, N_("Blur"), NULL },
+    { GIMP_SHARPEN_CONVOLVE, N_("Sharpen"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpConvolveType", values);
+    {
+      type = g_enum_register_static ("GimpConvolveType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -91,10 +133,21 @@ gimp_ink_blob_type_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_INK_BLOB_TYPE_ELLIPSE, "GIMP_INK_BLOB_TYPE_ELLIPSE", NULL },
+    { GIMP_INK_BLOB_TYPE_SQUARE, "GIMP_INK_BLOB_TYPE_SQUARE", NULL },
+    { GIMP_INK_BLOB_TYPE_DIAMOND, "GIMP_INK_BLOB_TYPE_DIAMOND", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpInkBlobType", values);
+    {
+      type = g_enum_register_static ("GimpInkBlobType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -104,15 +157,25 @@ gimp_paint_application_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_PAINT_CONSTANT, N_("Constant"), "constant" },
-    { GIMP_PAINT_INCREMENTAL, N_("Incremental"), "incremental" },
+    { GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
+    { GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_PAINT_CONSTANT, N_("Constant"), NULL },
+    { GIMP_PAINT_INCREMENTAL, N_("Incremental"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpPaintApplicationMode", values);
+    {
+      type = g_enum_register_static ("GimpPaintApplicationMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/plug-in/gimpplugin.c b/app/plug-in/gimpplugin.c
index 3fac5fe17b..e54805a7bc 100644
--- a/app/plug-in/gimpplugin.c
+++ b/app/plug-in/gimpplugin.c
@@ -538,7 +538,11 @@ plug_in_close (PlugIn   *plug_in,
   /* If necessary, kill the filter. */
 #ifndef G_OS_WIN32
   if (kill_it && plug_in->pid)
-    status = kill (plug_in->pid, SIGKILL);
+    {
+      g_warning ("Terminating %s ...",
+                 gimp_filename_to_utf8 (plug_in->prog));
+      status = kill (plug_in->pid, SIGKILL);
+    }
 
   /* Wait for the process to exit. This will happen
    *  immediately if it was just killed.
diff --git a/app/plug-in/plug-in.c b/app/plug-in/plug-in.c
index 3fac5fe17b..e54805a7bc 100644
--- a/app/plug-in/plug-in.c
+++ b/app/plug-in/plug-in.c
@@ -538,7 +538,11 @@ plug_in_close (PlugIn   *plug_in,
   /* If necessary, kill the filter. */
 #ifndef G_OS_WIN32
   if (kill_it && plug_in->pid)
-    status = kill (plug_in->pid, SIGKILL);
+    {
+      g_warning ("Terminating %s ...",
+                 gimp_filename_to_utf8 (plug_in->prog));
+      status = kill (plug_in->pid, SIGKILL);
+    }
 
   /* Wait for the process to exit. This will happen
    *  immediately if it was just killed.
diff --git a/app/text/Makefile.am b/app/text/Makefile.am
index fb5aa189a2..a925e0d676 100644
--- a/app/text/Makefile.am
+++ b/app/text/Makefile.am
@@ -64,11 +64,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/text-enums.c: $(srcdir)/text-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"text-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"text-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/text-enums.h > xgen-tec \
 	&& cp xgen-tec $(@F) \
 	&& rm -f xgen-tec
diff --git a/app/text/text-enums.c b/app/text/text-enums.c
index 80c640aae9..9161f70a29 100644
--- a/app/text/text-enums.c
+++ b/app/text/text-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "text-enums.h"
 #include "gimp-intl.h"
 
@@ -17,10 +18,20 @@ gimp_text_box_mode_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TEXT_BOX_DYNAMIC, "GIMP_TEXT_BOX_DYNAMIC", NULL },
+    { GIMP_TEXT_BOX_FIXED, "GIMP_TEXT_BOX_FIXED", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTextBoxMode", values);
+    {
+      type = g_enum_register_static ("GimpTextBoxMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -30,15 +41,25 @@ gimp_text_direction_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TEXT_DIRECTION_LTR, N_("From left to right"), "ltr" },
-    { GIMP_TEXT_DIRECTION_RTL, N_("From right to left"), "rtl" },
+    { 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_TEXT_DIRECTION_LTR, N_("From left to right"), NULL },
+    { GIMP_TEXT_DIRECTION_RTL, N_("From right to left"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTextDirection", values);
+    {
+      type = g_enum_register_static ("GimpTextDirection", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -48,17 +69,29 @@ gimp_text_justification_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TEXT_JUSTIFY_LEFT, N_("Left justified"), "left" },
-    { GIMP_TEXT_JUSTIFY_RIGHT, N_("Right justified"), "right" },
-    { GIMP_TEXT_JUSTIFY_CENTER, N_("Centered"), "center" },
-    { GIMP_TEXT_JUSTIFY_FILL, N_("Filled"), "fill" },
+    { 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_TEXT_JUSTIFY_LEFT, N_("Left justified"), NULL },
+    { GIMP_TEXT_JUSTIFY_RIGHT, N_("Right justified"), NULL },
+    { GIMP_TEXT_JUSTIFY_CENTER, N_("Centered"), NULL },
+    { GIMP_TEXT_JUSTIFY_FILL, N_("Filled"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTextJustification", values);
+    {
+      type = g_enum_register_static ("GimpTextJustification", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -74,10 +107,21 @@ gimp_text_outline_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TEXT_OUTLINE_NONE, "GIMP_TEXT_OUTLINE_NONE", NULL },
+    { GIMP_TEXT_OUTLINE_STROKE_ONLY, "GIMP_TEXT_OUTLINE_STROKE_ONLY", NULL },
+    { GIMP_TEXT_OUTLINE_STROKE_FILL, "GIMP_TEXT_OUTLINE_STROKE_FILL", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTextOutline", values);
+    {
+      type = g_enum_register_static ("GimpTextOutline", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/tools/Makefile.am b/app/tools/Makefile.am
index 577bdfd9c9..7af9ee701c 100644
--- a/app/tools/Makefile.am
+++ b/app/tools/Makefile.am
@@ -170,11 +170,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/tools-enums.c: $(srcdir)/tools-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"core/core-enums.h\"\n#include \"tools-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"core/core-enums.h\"\n#include \"tools-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/tools-enums.h > xgen-tec \
 	&& cp xgen-tec $(@F) \
 	&& rm -f xgen-tec
diff --git a/app/tools/tools-enums.c b/app/tools/tools-enums.c
index 290eab3829..ea4bf5320c 100644
--- a/app/tools/tools-enums.c
+++ b/app/tools/tools-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <glib-object.h>
+#include "libgimpbase/gimpbase.h"
 #include "core/core-enums.h"
 #include "tools-enums.h"
 #include "gimp-intl.h"
@@ -13,16 +14,27 @@ gimp_color_pick_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_COLOR_PICK_MODE_NONE, N_("Pick only"), "none" },
-    { GIMP_COLOR_PICK_MODE_FOREGROUND, N_("Set foreground color"), "foreground" },
-    { GIMP_COLOR_PICK_MODE_BACKGROUND, N_("Set background color"), "background" },
+    { GIMP_COLOR_PICK_MODE_NONE, "GIMP_COLOR_PICK_MODE_NONE", "none" },
+    { GIMP_COLOR_PICK_MODE_FOREGROUND, "GIMP_COLOR_PICK_MODE_FOREGROUND", "foreground" },
+    { GIMP_COLOR_PICK_MODE_BACKGROUND, "GIMP_COLOR_PICK_MODE_BACKGROUND", "background" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_COLOR_PICK_MODE_NONE, N_("Pick only"), NULL },
+    { GIMP_COLOR_PICK_MODE_FOREGROUND, N_("Set foreground color"), NULL },
+    { GIMP_COLOR_PICK_MODE_BACKGROUND, N_("Set background color"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpColorPickMode", values);
+    {
+      type = g_enum_register_static ("GimpColorPickMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -32,15 +44,25 @@ gimp_crop_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CROP_MODE_CROP, N_("Crop"), "crop" },
-    { GIMP_CROP_MODE_RESIZE, N_("Resize"), "resize" },
+    { GIMP_CROP_MODE_CROP, "GIMP_CROP_MODE_CROP", "crop" },
+    { GIMP_CROP_MODE_RESIZE, "GIMP_CROP_MODE_RESIZE", "resize" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CROP_MODE_CROP, N_("Crop"), NULL },
+    { GIMP_CROP_MODE_RESIZE, N_("Resize"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCropMode", values);
+    {
+      type = g_enum_register_static ("GimpCropMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -50,16 +72,27 @@ gimp_rect_select_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_RECT_SELECT_MODE_FREE, N_("Free select"), "free" },
-    { GIMP_RECT_SELECT_MODE_FIXED_SIZE, N_("Fixed size"), "fixed-size" },
-    { GIMP_RECT_SELECT_MODE_FIXED_RATIO, N_("Fixed aspect ratio"), "fixed-ratio" },
+    { GIMP_RECT_SELECT_MODE_FREE, "GIMP_RECT_SELECT_MODE_FREE", "free" },
+    { GIMP_RECT_SELECT_MODE_FIXED_SIZE, "GIMP_RECT_SELECT_MODE_FIXED_SIZE", "fixed-size" },
+    { GIMP_RECT_SELECT_MODE_FIXED_RATIO, "GIMP_RECT_SELECT_MODE_FIXED_RATIO", "fixed-ratio" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_RECT_SELECT_MODE_FREE, N_("Free select"), NULL },
+    { GIMP_RECT_SELECT_MODE_FIXED_SIZE, N_("Fixed size"), NULL },
+    { GIMP_RECT_SELECT_MODE_FIXED_RATIO, N_("Fixed aspect ratio"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpRectSelectMode", values);
+    {
+      type = g_enum_register_static ("GimpRectSelectMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -69,16 +102,27 @@ gimp_transform_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_TYPE_LAYER, N_("Transform layer"), "layer" },
-    { GIMP_TRANSFORM_TYPE_SELECTION, N_("Transform selection"), "selection" },
-    { GIMP_TRANSFORM_TYPE_PATH, N_("Transform path"), "path" },
+    { GIMP_TRANSFORM_TYPE_LAYER, "GIMP_TRANSFORM_TYPE_LAYER", "layer" },
+    { GIMP_TRANSFORM_TYPE_SELECTION, "GIMP_TRANSFORM_TYPE_SELECTION", "selection" },
+    { GIMP_TRANSFORM_TYPE_PATH, "GIMP_TRANSFORM_TYPE_PATH", "path" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TRANSFORM_TYPE_LAYER, N_("Transform layer"), NULL },
+    { GIMP_TRANSFORM_TYPE_SELECTION, N_("Transform selection"), NULL },
+    { GIMP_TRANSFORM_TYPE_PATH, N_("Transform path"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTransformType", values);
+    {
+      type = g_enum_register_static ("GimpTransformType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -88,16 +132,27 @@ gimp_vector_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_VECTOR_MODE_DESIGN, N_("Design"), "design" },
-    { GIMP_VECTOR_MODE_EDIT, N_("Edit"), "edit" },
-    { GIMP_VECTOR_MODE_MOVE, N_("Move"), "move" },
+    { GIMP_VECTOR_MODE_DESIGN, "GIMP_VECTOR_MODE_DESIGN", "design" },
+    { GIMP_VECTOR_MODE_EDIT, "GIMP_VECTOR_MODE_EDIT", "edit" },
+    { GIMP_VECTOR_MODE_MOVE, "GIMP_VECTOR_MODE_MOVE", "move" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_VECTOR_MODE_DESIGN, N_("Design"), NULL },
+    { GIMP_VECTOR_MODE_EDIT, N_("Edit"), NULL },
+    { GIMP_VECTOR_MODE_MOVE, N_("Move"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpVectorMode", values);
+    {
+      type = g_enum_register_static ("GimpVectorMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -107,17 +162,29 @@ gimp_transform_preview_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, N_("Outline"), "outline" },
-    { GIMP_TRANSFORM_PREVIEW_TYPE_GRID, N_("Grid"), "grid" },
-    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, N_("Image"), "image" },
-    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, N_("Image + Grid"), "image-grid" },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, "GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE", "outline" },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_GRID, "GIMP_TRANSFORM_PREVIEW_TYPE_GRID", "grid" },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, "GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE", "image" },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, "GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID", "image-grid" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TRANSFORM_PREVIEW_TYPE_OUTLINE, N_("Outline"), NULL },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_GRID, N_("Grid"), NULL },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE, N_("Image"), NULL },
+    { GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID, N_("Image + Grid"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTransformPreviewType", values);
+    {
+      type = g_enum_register_static ("GimpTransformPreviewType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -127,15 +194,25 @@ gimp_transform_grid_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TRANSFORM_GRID_TYPE_N_LINES, N_("Number of grid lines"), "n-lines" },
-    { GIMP_TRANSFORM_GRID_TYPE_SPACING, N_("Grid line spacing"), "spacing" },
+    { GIMP_TRANSFORM_GRID_TYPE_N_LINES, "GIMP_TRANSFORM_GRID_TYPE_N_LINES", "n-lines" },
+    { GIMP_TRANSFORM_GRID_TYPE_SPACING, "GIMP_TRANSFORM_GRID_TYPE_SPACING", "spacing" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TRANSFORM_GRID_TYPE_N_LINES, N_("Number of grid lines"), NULL },
+    { GIMP_TRANSFORM_GRID_TYPE_SPACING, N_("Grid line spacing"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTransformGridType", values);
+    {
+      type = g_enum_register_static ("GimpTransformGridType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/app/widgets/Makefile.am b/app/widgets/Makefile.am
index b6c3fee75b..6a687fc54f 100644
--- a/app/widgets/Makefile.am
+++ b/app/widgets/Makefile.am
@@ -301,11 +301,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/widgets-enums.c: $(srcdir)/widgets-enums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <gtk/gtk.h>\n#include \"widgets-enums.h\"\n#include \"gimp-intl.h\"" \
+		--fhead "#include \"config.h\"\n#include <gtk/gtk.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"widgets-enums.h\"\n#include \"gimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/widgets-enums.h > xgen-wec \
 	&& cp xgen-wec $(@F) \
 	&& rm -f xgen-wec
diff --git a/app/widgets/gimpenumstore.c b/app/widgets/gimpenumstore.c
index 6a04db41a1..a700485639 100644
--- a/app/widgets/gimpenumstore.c
+++ b/app/widgets/gimpenumstore.c
@@ -96,14 +96,14 @@ gimp_enum_store_add_value (GtkListStore *store,
                            GEnumValue   *value)
 {
   GtkTreeIter  iter;
-  const gchar *name;
+  const gchar *desc;
 
-  name = gimp_enum_value_get_name (GIMP_ENUM_STORE (store)->enum_class, value);
+  desc = gimp_enum_value_get_desc (GIMP_ENUM_STORE (store)->enum_class, value);
 
   gtk_list_store_append (store, &iter);
   gtk_list_store_set (store, &iter,
                       GIMP_INT_STORE_VALUE, value->value,
-                      GIMP_INT_STORE_LABEL, name,
+                      GIMP_INT_STORE_LABEL, desc,
                       -1);
 }
 
diff --git a/app/widgets/gimpenumwidgets.c b/app/widgets/gimpenumwidgets.c
index ba8b55fcb2..b609a8efcf 100644
--- a/app/widgets/gimpenumwidgets.c
+++ b/app/widgets/gimpenumwidgets.c
@@ -95,14 +95,14 @@ gimp_enum_radio_box_new_with_range (GType       enum_type,
 
   for (value = enum_class->values; value->value_name; value++)
     {
-      const gchar *name;
+      const gchar *desc;
 
       if (value->value < minimum || value->value > maximum)
         continue;
 
-      name = gimp_enum_value_get_name (enum_class, value);
+      desc = gimp_enum_value_get_desc (enum_class, value);
 
-      button = gtk_radio_button_new_with_mnemonic (group, name);
+      button = gtk_radio_button_new_with_mnemonic (group, desc);
 
       if (first_button && *first_button == NULL)
         *first_button = button;
@@ -303,7 +303,7 @@ gimp_enum_stock_box_new_with_range (GType         enum_type,
         }
 
       gimp_help_set_help_data (button,
-                               gimp_enum_value_get_name (enum_class, value),
+                               gimp_enum_value_get_desc (enum_class, value),
                                NULL);
 
       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
diff --git a/app/widgets/gimptemplateeditor.c b/app/widgets/gimptemplateeditor.c
index 6dd0472823..c2c0deeb54 100644
--- a/app/widgets/gimptemplateeditor.c
+++ b/app/widgets/gimptemplateeditor.c
@@ -646,7 +646,7 @@ gimp_template_editor_template_notify (GimpTemplate       *template,
                                       GimpTemplateEditor *editor)
 {
   GimpAspectType  aspect;
-  const gchar    *name;
+  const gchar    *desc;
   gchar          *text;
 
   if (param_spec)
@@ -685,15 +685,15 @@ gimp_template_editor_template_notify (GimpTemplate       *template,
   editor->block_aspect = FALSE;
 
   gimp_enum_get_value (GIMP_TYPE_IMAGE_BASE_TYPE, template->image_type,
-                       NULL, &name);
+                       NULL, NULL, &desc, NULL);
 
   if ((gint) template->xresolution != (gint) template->yresolution)
     text = g_strdup_printf (_("%d x %d dpi, %s"),
                             (gint) template->xresolution,
-                            (gint) template->yresolution, name);
+                            (gint) template->yresolution, desc);
   else
     text = g_strdup_printf (_("%d dpi, %s"),
-                            (gint) template->yresolution, name);
+                            (gint) template->yresolution, desc);
 
   gtk_label_set_text (GTK_LABEL (editor->more_label), text);
   g_free (text);
diff --git a/app/widgets/widgets-enums.c b/app/widgets/widgets-enums.c
index b0d0cb87da..fc0033eb18 100644
--- a/app/widgets/widgets-enums.c
+++ b/app/widgets/widgets-enums.c
@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include <gtk/gtk.h>
+#include "libgimpbase/gimpbase.h"
 #include "widgets-enums.h"
 #include "gimp-intl.h"
 
@@ -12,15 +13,25 @@ gimp_active_color_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ACTIVE_COLOR_FOREGROUND, N_("Foreground"), "foreground" },
-    { GIMP_ACTIVE_COLOR_BACKGROUND, N_("Background"), "background" },
+    { GIMP_ACTIVE_COLOR_FOREGROUND, "GIMP_ACTIVE_COLOR_FOREGROUND", "foreground" },
+    { GIMP_ACTIVE_COLOR_BACKGROUND, "GIMP_ACTIVE_COLOR_BACKGROUND", "background" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_ACTIVE_COLOR_FOREGROUND, N_("Foreground"), NULL },
+    { GIMP_ACTIVE_COLOR_BACKGROUND, N_("Background"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpActiveColor", values);
+    {
+      type = g_enum_register_static ("GimpActiveColor", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -31,15 +42,26 @@ gimp_aspect_type_get_type (void)
   static const GEnumValue values[] =
   {
     { GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", "square" },
-    { GIMP_ASPECT_PORTRAIT, N_("Portrait"), "portrait" },
-    { GIMP_ASPECT_LANDSCAPE, N_("Landscape"), "landscape" },
+    { GIMP_ASPECT_PORTRAIT, "GIMP_ASPECT_PORTRAIT", "portrait" },
+    { GIMP_ASPECT_LANDSCAPE, "GIMP_ASPECT_LANDSCAPE", "landscape" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", NULL },
+    { GIMP_ASPECT_PORTRAIT, N_("Portrait"), NULL },
+    { GIMP_ASPECT_LANDSCAPE, N_("Landscape"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpAspectType", values);
+    {
+      type = g_enum_register_static ("GimpAspectType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -55,10 +77,21 @@ gimp_color_dialog_state_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_COLOR_DIALOG_OK, "GIMP_COLOR_DIALOG_OK", NULL },
+    { GIMP_COLOR_DIALOG_CANCEL, "GIMP_COLOR_DIALOG_CANCEL", NULL },
+    { GIMP_COLOR_DIALOG_UPDATE, "GIMP_COLOR_DIALOG_UPDATE", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpColorDialogState", values);
+    {
+      type = g_enum_register_static ("GimpColorDialogState", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -68,17 +101,29 @@ gimp_color_frame_mode_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_COLOR_FRAME_MODE_PIXEL, N_("Pixel values"), "pixel" },
-    { GIMP_COLOR_FRAME_MODE_RGB, N_("RGB"), "rgb" },
-    { GIMP_COLOR_FRAME_MODE_HSV, N_("HSV"), "hsv" },
-    { GIMP_COLOR_FRAME_MODE_CMYK, N_("CMYK"), "cmyk" },
+    { GIMP_COLOR_FRAME_MODE_PIXEL, "GIMP_COLOR_FRAME_MODE_PIXEL", "pixel" },
+    { GIMP_COLOR_FRAME_MODE_RGB, "GIMP_COLOR_FRAME_MODE_RGB", "rgb" },
+    { GIMP_COLOR_FRAME_MODE_HSV, "GIMP_COLOR_FRAME_MODE_HSV", "hsv" },
+    { GIMP_COLOR_FRAME_MODE_CMYK, "GIMP_COLOR_FRAME_MODE_CMYK", "cmyk" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_COLOR_FRAME_MODE_PIXEL, N_("Pixel values"), NULL },
+    { GIMP_COLOR_FRAME_MODE_RGB, N_("RGB"), NULL },
+    { GIMP_COLOR_FRAME_MODE_HSV, N_("HSV"), NULL },
+    { GIMP_COLOR_FRAME_MODE_CMYK, N_("CMYK"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpColorFrameMode", values);
+    {
+      type = g_enum_register_static ("GimpColorFrameMode", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -93,10 +138,20 @@ gimp_color_pick_state_get_type (void)
     { 0, NULL, NULL }
   };
 
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_COLOR_PICK_STATE_NEW, "GIMP_COLOR_PICK_STATE_NEW", NULL },
+    { GIMP_COLOR_PICK_STATE_UPDATE, "GIMP_COLOR_PICK_STATE_UPDATE", NULL },
+    { 0, NULL, NULL }
+  };
+
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpColorPickState", values);
+    {
+      type = g_enum_register_static ("GimpColorPickState", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -106,15 +161,25 @@ gimp_cursor_format_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CURSOR_FORMAT_BITMAP, N_("Black & white"), "bitmap" },
-    { GIMP_CURSOR_FORMAT_PIXBUF, N_("Fancy"), "pixbuf" },
+    { GIMP_CURSOR_FORMAT_BITMAP, "GIMP_CURSOR_FORMAT_BITMAP", "bitmap" },
+    { GIMP_CURSOR_FORMAT_PIXBUF, "GIMP_CURSOR_FORMAT_PIXBUF", "pixbuf" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CURSOR_FORMAT_BITMAP, N_("Black & white"), NULL },
+    { GIMP_CURSOR_FORMAT_PIXBUF, N_("Fancy"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpCursorFormat", values);
+    {
+      type = g_enum_register_static ("GimpCursorFormat", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -124,15 +189,25 @@ gimp_help_browser_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_HELP_BROWSER_GIMP, N_("GIMP help browser"), "gimp" },
-    { GIMP_HELP_BROWSER_WEB_BROWSER, N_("Web browser"), "web-browser" },
+    { GIMP_HELP_BROWSER_GIMP, "GIMP_HELP_BROWSER_GIMP", "gimp" },
+    { GIMP_HELP_BROWSER_WEB_BROWSER, "GIMP_HELP_BROWSER_WEB_BROWSER", "web-browser" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_HELP_BROWSER_GIMP, N_("GIMP help browser"), NULL },
+    { GIMP_HELP_BROWSER_WEB_BROWSER, N_("Web browser"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpHelpBrowserType", values);
+    {
+      type = g_enum_register_static ("GimpHelpBrowserType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -142,15 +217,25 @@ gimp_histogram_scale_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_HISTOGRAM_SCALE_LINEAR, N_("Linear"), "linear" },
-    { GIMP_HISTOGRAM_SCALE_LOGARITHMIC, N_("Logarithmic"), "logarithmic" },
+    { GIMP_HISTOGRAM_SCALE_LINEAR, "GIMP_HISTOGRAM_SCALE_LINEAR", "linear" },
+    { GIMP_HISTOGRAM_SCALE_LOGARITHMIC, "GIMP_HISTOGRAM_SCALE_LOGARITHMIC", "logarithmic" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_HISTOGRAM_SCALE_LINEAR, N_("Linear"), NULL },
+    { GIMP_HISTOGRAM_SCALE_LOGARITHMIC, N_("Logarithmic"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpHistogramScale", values);
+    {
+      type = g_enum_register_static ("GimpHistogramScale", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -160,21 +245,37 @@ gimp_tab_style_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_TAB_STYLE_ICON, N_("Icon"), "icon" },
-    { GIMP_TAB_STYLE_PREVIEW, N_("Current status"), "preview" },
-    { GIMP_TAB_STYLE_NAME, N_("Text"), "name" },
-    { GIMP_TAB_STYLE_BLURB, N_("Description"), "blurb" },
-    { GIMP_TAB_STYLE_ICON_NAME, N_("Icon & text"), "icon-name" },
-    { GIMP_TAB_STYLE_ICON_BLURB, N_("Icon & desc"), "icon-blurb" },
-    { GIMP_TAB_STYLE_PREVIEW_NAME, N_("Status & text"), "preview-name" },
-    { GIMP_TAB_STYLE_PREVIEW_BLURB, N_("Status & desc"), "preview-blurb" },
+    { GIMP_TAB_STYLE_ICON, "GIMP_TAB_STYLE_ICON", "icon" },
+    { GIMP_TAB_STYLE_PREVIEW, "GIMP_TAB_STYLE_PREVIEW", "preview" },
+    { GIMP_TAB_STYLE_NAME, "GIMP_TAB_STYLE_NAME", "name" },
+    { GIMP_TAB_STYLE_BLURB, "GIMP_TAB_STYLE_BLURB", "blurb" },
+    { GIMP_TAB_STYLE_ICON_NAME, "GIMP_TAB_STYLE_ICON_NAME", "icon-name" },
+    { GIMP_TAB_STYLE_ICON_BLURB, "GIMP_TAB_STYLE_ICON_BLURB", "icon-blurb" },
+    { GIMP_TAB_STYLE_PREVIEW_NAME, "GIMP_TAB_STYLE_PREVIEW_NAME", "preview-name" },
+    { GIMP_TAB_STYLE_PREVIEW_BLURB, "GIMP_TAB_STYLE_PREVIEW_BLURB", "preview-blurb" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_TAB_STYLE_ICON, N_("Icon"), NULL },
+    { GIMP_TAB_STYLE_PREVIEW, N_("Current status"), NULL },
+    { GIMP_TAB_STYLE_NAME, N_("Text"), NULL },
+    { GIMP_TAB_STYLE_BLURB, N_("Description"), NULL },
+    { GIMP_TAB_STYLE_ICON_NAME, N_("Icon & text"), NULL },
+    { GIMP_TAB_STYLE_ICON_BLURB, N_("Icon & desc"), NULL },
+    { GIMP_TAB_STYLE_PREVIEW_NAME, N_("Status & text"), NULL },
+    { GIMP_TAB_STYLE_PREVIEW_BLURB, N_("Status & desc"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpTabStyle", values);
+    {
+      type = g_enum_register_static ("GimpTabStyle", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -184,15 +285,25 @@ gimp_view_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_VIEW_TYPE_LIST, N_("View as list"), "list" },
-    { GIMP_VIEW_TYPE_GRID, N_("View as grid"), "grid" },
+    { GIMP_VIEW_TYPE_LIST, "GIMP_VIEW_TYPE_LIST", "list" },
+    { GIMP_VIEW_TYPE_GRID, "GIMP_VIEW_TYPE_GRID", "grid" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_VIEW_TYPE_LIST, N_("View as list"), NULL },
+    { GIMP_VIEW_TYPE_GRID, N_("View as grid"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpViewType", values);
+    {
+      type = g_enum_register_static ("GimpViewType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -202,16 +313,27 @@ gimp_window_hint_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_WINDOW_HINT_NORMAL, N_("Normal window"), "normal" },
-    { GIMP_WINDOW_HINT_UTILITY, N_("Utility window"), "utility" },
-    { GIMP_WINDOW_HINT_KEEP_ABOVE, N_("Keep above"), "keep-above" },
+    { GIMP_WINDOW_HINT_NORMAL, "GIMP_WINDOW_HINT_NORMAL", "normal" },
+    { GIMP_WINDOW_HINT_UTILITY, "GIMP_WINDOW_HINT_UTILITY", "utility" },
+    { GIMP_WINDOW_HINT_KEEP_ABOVE, "GIMP_WINDOW_HINT_KEEP_ABOVE", "keep-above" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_WINDOW_HINT_NORMAL, N_("Normal window"), NULL },
+    { GIMP_WINDOW_HINT_UTILITY, N_("Utility window"), NULL },
+    { GIMP_WINDOW_HINT_KEEP_ABOVE, N_("Keep above"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpWindowHint", values);
+    {
+      type = g_enum_register_static ("GimpWindowHint", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -221,15 +343,25 @@ gimp_zoom_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_ZOOM_IN, N_("Zoom in"), "in" },
-    { GIMP_ZOOM_OUT, N_("Zoom out"), "out" },
+    { GIMP_ZOOM_IN, "GIMP_ZOOM_IN", "in" },
+    { GIMP_ZOOM_OUT, "GIMP_ZOOM_OUT", "out" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_ZOOM_IN, N_("Zoom in"), NULL },
+    { GIMP_ZOOM_OUT, N_("Zoom out"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-    type = g_enum_register_static ("GimpZoomType", values);
+    {
+      type = g_enum_register_static ("GimpZoomType", values);
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/libgimp/Makefile.am b/libgimp/Makefile.am
index d9d6011edb..135be91bc3 100644
--- a/libgimp/Makefile.am
+++ b/libgimp/Makefile.am
@@ -334,11 +334,14 @@ CLEANFILES = $(gen_sources)
 
 $(srcdir)/gimpenums.c: $(srcdir)/gimpenums.h $(GIMP_MKENUMS)
 	$(GIMP_MKENUMS) \
-		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"gimpenums.h\"" \
+		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"libgimpbase/gimpbase.h\"\n#include \"gimpenums.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    type = g_@type@_register_static (\"@EnumName@\", values);\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/gimpenums.h > xgen-cec \
 	&& cp xgen-cec $(@F) \
 	&& rm -f xgen-cec
diff --git a/libgimpbase/Makefile.am b/libgimpbase/Makefile.am
index 441d17b721..cf739a7e47 100644
--- a/libgimpbase/Makefile.am
+++ b/libgimpbase/Makefile.am
@@ -151,8 +151,11 @@ $(srcdir)/gimpbaseenums.c: $(srcdir)/gimpbaseenums.h $(GIMP_MKENUMS)
 		--fhead "#include \"config.h\"\n#include <glib-object.h>\n#include \"gimpbasetypes.h\"\n#include \"libgimp/libgimp-intl.h\"" \
 		--fprod "\n/* enumerations from \"@filename@\" */" \
 		--vhead "GType\n@enum_name@_get_type (void)\n{\n  static const G@Type@Value values[] =\n  {" \
-		--vprod "    { @VALUENAME@, @valuedesc@, \"@valuenick@\" }," \
-		--vtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n  {\n    type = g_@type@_register_static (\"@EnumName@\", values);\n    gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n  }\n\n  return type;\n}\n" \
+		--vprod "    { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "    { 0, NULL, NULL }\n  };\n" \
+		--dhead "  static const Gimp@Type@Desc descs[] =\n  {" \
+		--dprod "    { @VALUENAME@, @valuedesc@, @valuehelp@ }," \
+		--dtail "    { 0, NULL, NULL }\n  };\n\n  static GType type = 0;\n\n  if (! type)\n    {\n      type = g_@type@_register_static (\"@EnumName@\", values);\n      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE \"-libgimp\");\n      gimp_@type@_set_value_descriptions (type, descs);\n    }\n\n  return type;\n}\n" \
 		$(srcdir)/gimpbaseenums.h > xgen-bec \
 	&& cp xgen-bec $(@F) \
 	&& rm -f xgen-bec
diff --git a/libgimpbase/gimpbaseenums.c b/libgimpbase/gimpbaseenums.c
index 3aedb348cd..b2e0bddcfa 100644
--- a/libgimpbase/gimpbaseenums.c
+++ b/libgimpbase/gimpbaseenums.c
@@ -12,19 +12,28 @@ gimp_check_size_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CHECK_SIZE_SMALL_CHECKS, N_("Small"), "small-checks" },
-    { GIMP_CHECK_SIZE_MEDIUM_CHECKS, N_("Medium"), "medium-checks" },
-    { GIMP_CHECK_SIZE_LARGE_CHECKS, N_("Large"), "large-checks" },
+    { GIMP_CHECK_SIZE_SMALL_CHECKS, "GIMP_CHECK_SIZE_SMALL_CHECKS", "small-checks" },
+    { GIMP_CHECK_SIZE_MEDIUM_CHECKS, "GIMP_CHECK_SIZE_MEDIUM_CHECKS", "medium-checks" },
+    { GIMP_CHECK_SIZE_LARGE_CHECKS, "GIMP_CHECK_SIZE_LARGE_CHECKS", "large-checks" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CHECK_SIZE_SMALL_CHECKS, N_("Small"), NULL },
+    { GIMP_CHECK_SIZE_MEDIUM_CHECKS, N_("Medium"), NULL },
+    { GIMP_CHECK_SIZE_LARGE_CHECKS, N_("Large"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-  {
-    type = g_enum_register_static ("GimpCheckSize", values);
-    gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-  }
+    {
+      type = g_enum_register_static ("GimpCheckSize", values);
+      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -34,22 +43,34 @@ gimp_check_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_CHECK_TYPE_LIGHT_CHECKS, N_("Light Checks"), "light-checks" },
-    { GIMP_CHECK_TYPE_GRAY_CHECKS, N_("Mid-Tone Checks"), "gray-checks" },
-    { GIMP_CHECK_TYPE_DARK_CHECKS, N_("Dark Checks"), "dark-checks" },
-    { GIMP_CHECK_TYPE_WHITE_ONLY, N_("White Only"), "white-only" },
-    { GIMP_CHECK_TYPE_GRAY_ONLY, N_("Gray Only"), "gray-only" },
-    { GIMP_CHECK_TYPE_BLACK_ONLY, N_("Black Only"), "black-only" },
+    { GIMP_CHECK_TYPE_LIGHT_CHECKS, "GIMP_CHECK_TYPE_LIGHT_CHECKS", "light-checks" },
+    { GIMP_CHECK_TYPE_GRAY_CHECKS, "GIMP_CHECK_TYPE_GRAY_CHECKS", "gray-checks" },
+    { GIMP_CHECK_TYPE_DARK_CHECKS, "GIMP_CHECK_TYPE_DARK_CHECKS", "dark-checks" },
+    { GIMP_CHECK_TYPE_WHITE_ONLY, "GIMP_CHECK_TYPE_WHITE_ONLY", "white-only" },
+    { GIMP_CHECK_TYPE_GRAY_ONLY, "GIMP_CHECK_TYPE_GRAY_ONLY", "gray-only" },
+    { GIMP_CHECK_TYPE_BLACK_ONLY, "GIMP_CHECK_TYPE_BLACK_ONLY", "black-only" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_CHECK_TYPE_LIGHT_CHECKS, N_("Light Checks"), NULL },
+    { GIMP_CHECK_TYPE_GRAY_CHECKS, N_("Mid-Tone Checks"), NULL },
+    { GIMP_CHECK_TYPE_DARK_CHECKS, N_("Dark Checks"), NULL },
+    { GIMP_CHECK_TYPE_WHITE_ONLY, N_("White Only"), NULL },
+    { GIMP_CHECK_TYPE_GRAY_ONLY, N_("Gray Only"), NULL },
+    { GIMP_CHECK_TYPE_BLACK_ONLY, N_("Black Only"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-  {
-    type = g_enum_register_static ("GimpCheckType", values);
-    gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-  }
+    {
+      type = g_enum_register_static ("GimpCheckType", values);
+      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -59,19 +80,28 @@ gimp_image_base_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_RGB, N_("RGB color"), "rgb" },
-    { GIMP_GRAY, N_("Grayscale"), "gray" },
-    { GIMP_INDEXED, N_("Indexed color"), "indexed" },
+    { GIMP_RGB, "GIMP_RGB", "rgb" },
+    { GIMP_GRAY, "GIMP_GRAY", "gray" },
+    { GIMP_INDEXED, "GIMP_INDEXED", "indexed" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_RGB, N_("RGB color"), NULL },
+    { GIMP_GRAY, N_("Grayscale"), NULL },
+    { GIMP_INDEXED, N_("Indexed color"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-  {
-    type = g_enum_register_static ("GimpImageBaseType", values);
-    gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-  }
+    {
+      type = g_enum_register_static ("GimpImageBaseType", values);
+      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
@@ -81,22 +111,34 @@ gimp_image_type_get_type (void)
 {
   static const GEnumValue values[] =
   {
-    { GIMP_RGB_IMAGE, N_("RGB"), "rgb-image" },
-    { GIMP_RGBA_IMAGE, N_("RGB-alpha"), "rgba-image" },
-    { GIMP_GRAY_IMAGE, N_("Grayscale"), "gray-image" },
-    { GIMP_GRAYA_IMAGE, N_("Grayscale-alpha"), "graya-image" },
-    { GIMP_INDEXED_IMAGE, N_("Indexed"), "indexed-image" },
-    { GIMP_INDEXEDA_IMAGE, N_("Indexed-alpha"), "indexeda-image" },
+    { GIMP_RGB_IMAGE, "GIMP_RGB_IMAGE", "rgb-image" },
+    { GIMP_RGBA_IMAGE, "GIMP_RGBA_IMAGE", "rgba-image" },
+    { GIMP_GRAY_IMAGE, "GIMP_GRAY_IMAGE", "gray-image" },
+    { GIMP_GRAYA_IMAGE, "GIMP_GRAYA_IMAGE", "graya-image" },
+    { GIMP_INDEXED_IMAGE, "GIMP_INDEXED_IMAGE", "indexed-image" },
+    { GIMP_INDEXEDA_IMAGE, "GIMP_INDEXEDA_IMAGE", "indexeda-image" },
+    { 0, NULL, NULL }
+  };
+
+  static const GimpEnumDesc descs[] =
+  {
+    { GIMP_RGB_IMAGE, N_("RGB"), NULL },
+    { GIMP_RGBA_IMAGE, N_("RGB-alpha"), NULL },
+    { GIMP_GRAY_IMAGE, N_("Grayscale"), NULL },
+    { GIMP_GRAYA_IMAGE, N_("Grayscale-alpha"), NULL },
+    { GIMP_INDEXED_IMAGE, N_("Indexed"), NULL },
+    { GIMP_INDEXEDA_IMAGE, N_("Indexed-alpha"), NULL },
     { 0, NULL, NULL }
   };
 
   static GType type = 0;
 
   if (! type)
-  {
-    type = g_enum_register_static ("GimpImageType", values);
-    gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
-  }
+    {
+      type = g_enum_register_static ("GimpImageType", values);
+      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
+      gimp_enum_set_value_descriptions (type, descs);
+    }
 
   return type;
 }
diff --git a/libgimpbase/gimpbasetypes.c b/libgimpbase/gimpbasetypes.c
index 6810ed49d7..a9f96cfddc 100644
--- a/libgimpbase/gimpbasetypes.c
+++ b/libgimpbase/gimpbasetypes.c
@@ -28,6 +28,7 @@
 
 
 static GQuark  gimp_translation_domain_quark (void) G_GNUC_CONST;
+static GQuark  gimp_value_descriptions_quark (void) G_GNUC_CONST;
 
 
 /**
@@ -71,6 +72,93 @@ gimp_type_get_translation_domain (GType type)
                                            gimp_translation_domain_quark ());
 }
 
+/**
+ * gimp_enum_set_value_descriptions:
+ * @enum_type:    a #GType
+ * @descriptions: a %NULL terminated constant static array of #GimpEnumDesc
+ *
+ * Sets the array of human readable and translatable descriptions
+ * and help texts for enum values.
+ *
+ * Since: GIMP 2.2
+ **/
+void
+gimp_enum_set_value_descriptions (GType               enum_type,
+                                  const GimpEnumDesc *descriptions)
+{
+  g_return_if_fail (g_type_is_a (enum_type, G_TYPE_ENUM));
+  g_return_if_fail (descriptions != NULL);
+
+  g_type_set_qdata (enum_type,
+                    gimp_value_descriptions_quark (),
+                    (gpointer) descriptions);
+}
+
+/**
+ * gimp_enum_get_value_descriptions:
+ * @enum_type: a #GType
+ *
+ * Retreives the array of human readable and translatable descriptions
+ * and help texts for enum values.
+ *
+ * Returns: a %NULL terminated constant array of #GimpEnumDesc
+ *
+ * Since: GIMP 2.2
+ **/
+const GimpEnumDesc *
+gimp_enum_get_value_descriptions (GType enum_type)
+{
+  g_return_val_if_fail (g_type_is_a (enum_type, G_TYPE_ENUM), NULL);
+
+  return (const GimpEnumDesc *)
+    g_type_get_qdata (enum_type, gimp_value_descriptions_quark ());
+}
+
+/**
+ * gimp_flags_set_value_descriptions:
+ * @flags_type:   a #GType
+ * @descriptions: a %NULL terminated constant static array of #GimpFlagsDesc
+ *
+ * Sets the array of human readable and translatable descriptions
+ * and help texts for flags values.
+ *
+ * Since: GIMP 2.2
+ **/
+void
+gimp_flags_set_value_descriptions (GType                flags_type,
+                                   const GimpFlagsDesc *descriptions)
+{
+  g_return_if_fail (g_type_is_a (flags_type, G_TYPE_FLAGS));
+  g_return_if_fail (descriptions != NULL);
+
+  g_type_set_qdata (flags_type,
+                    gimp_value_descriptions_quark (),
+                    (gpointer) descriptions);
+}
+
+/**
+ * gimp_flags_get_value_descriptions:
+ * @flags_type: a #GType
+ *
+ * Retreives the array of human readable and translatable descriptions
+ * and help texts for flags values.
+ *
+ * Returns: a %NULL terminated constant array of #GimpFlagsDesc
+ *
+ * Since: GIMP 2.2
+ **/
+const GimpFlagsDesc *
+gimp_flags_get_value_descriptions (GType flags_type)
+{
+  g_return_val_if_fail (g_type_is_a (flags_type, G_TYPE_FLAGS), NULL);
+
+  return (const GimpFlagsDesc *)
+    g_type_get_qdata (flags_type, gimp_value_descriptions_quark ());
+}
+
+
+/*  private functions  */
+
 static GQuark
 gimp_translation_domain_quark (void)
 {
@@ -81,3 +169,14 @@ gimp_translation_domain_quark (void)
 
   return quark;
 }
+
+static GQuark
+gimp_value_descriptions_quark (void)
+{
+  static GQuark quark = 0;
+
+  if (! quark)
+    quark = g_quark_from_static_string ("gimp-value-descriptions-quark");
+
+  return quark;
+}
diff --git a/libgimpbase/gimpbasetypes.h b/libgimpbase/gimpbasetypes.h
index 56d1b4e0ec..3fcc636d6a 100644
--- a/libgimpbase/gimpbasetypes.h
+++ b/libgimpbase/gimpbasetypes.h
@@ -33,15 +33,40 @@ G_BEGIN_DECLS
 
 typedef struct _GimpParasite     GimpParasite;
 typedef struct _GimpDatafileData GimpDatafileData;
+typedef struct _GimpEnumDesc     GimpEnumDesc;
+typedef struct _GimpFlagsDesc    GimpFlagsDesc;
 
 
 typedef void (* GimpDatafileLoaderFunc) (const GimpDatafileData *file_data,
                                          gpointer                user_data);
 
 
-void           gimp_type_set_translation_domain (GType        type,
-                                                 const gchar *domain);
-const gchar *  gimp_type_get_translation_domain (GType        type);
+struct _GimpEnumDesc
+{
+  gint   value;
+  gchar *value_desc;
+  gchar *value_help;
+};
+
+struct _GimpFlagsDesc
+{
+  guint  value;
+  gchar *value_desc;
+  gchar *value_help;
+};
+
+
+void                  gimp_type_set_translation_domain  (GType                type,
+                                                         const gchar         *domain);
+const gchar         * gimp_type_get_translation_domain  (GType                type);
+
+void                  gimp_enum_set_value_descriptions  (GType                enum_type,
+                                                         const GimpEnumDesc  *descriptions);
+const GimpEnumDesc  * gimp_enum_get_value_descriptions  (GType                enum_type);
+
+void                  gimp_flags_set_value_descriptions (GType                flags_type,
+                                                         const GimpFlagsDesc *descriptions);
+const GimpFlagsDesc * gimp_flags_get_value_descriptions (GType                flags_type);
 
 
 G_END_DECLS
diff --git a/libgimpbase/gimputils.c b/libgimpbase/gimputils.c
index 639216a3ff..009464c83e 100644
--- a/libgimpbase/gimputils.c
+++ b/libgimpbase/gimputils.c
@@ -302,17 +302,67 @@ gimp_escape_uline (const gchar *str)
   return escaped;
 }
 
+GimpEnumDesc *
+gimp_enum_get_desc (GEnumClass *enum_class,
+                    gint        value)
+{
+  const GimpEnumDesc *value_desc;
+
+  g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
+
+  value_desc = gimp_enum_get_value_descriptions (G_TYPE_FROM_CLASS (enum_class));
+
+  if (value_desc)
+    {
+      while (value_desc->value_desc)
+        {
+          if (value_desc->value == value)
+            return (GimpEnumDesc *) value_desc;
+
+          value_desc++;
+        }
+    }
+
+  return NULL;
+}
+
+GimpFlagsDesc *
+gimp_flags_get_first_desc (GFlagsClass *flags_class,
+                           guint        value)
+{
+  const GimpFlagsDesc *value_desc;
+
+  g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
+
+  value_desc = gimp_flags_get_value_descriptions (G_TYPE_FROM_CLASS (flags_class));
+
+  if (value_desc)
+    {
+      while (value_desc->value_desc)
+        {
+          if ((value_desc->value & value) == value_desc->value)
+            return (GimpFlagsDesc *) value_desc;
+
+          value_desc++;
+        }
+    }
+
+  return NULL;
+}
 
 /**
  * gimp_enum_get_value:
  * @enum_type:  the #GType of a registered enum
  * @value:      an integer value
+ * @value_name: return location for the value's name (or %NULL)
  * @value_nick: return location for the value's nick (or %NULL)
- * @value_name: return location for the value's translated name (or %NULL)
+ * @value_desc: return location for the value's translated desc (or %NULL)
+ * @value_help: return location for the value's translated help (or %NULL)
  *
  * Checks if @value is valid for the enum registered as @enum_type.
- * If the value exists in that enum, its nick and its translated name
- * are returned (if @value_nick and @value_name are not %NULL).
+ * If the value exists in that enum, its name, nick and its translated
+ * desc and help are returned (if @value_name, @value_nick, @value_desc
+ * and @value_help are not %NULL).
  *
  * Return value: %TRUE if @value is valid for the @enum_type,
  *               %FALSE otherwise
@@ -322,8 +372,10 @@ gimp_escape_uline (const gchar *str)
 gboolean
 gimp_enum_get_value (GType         enum_type,
                      gint          value,
+                     const gchar **value_name,
                      const gchar **value_nick,
-                     const gchar **value_name)
+                     const gchar **value_desc,
+                     const gchar **value_help)
 {
   GEnumClass *enum_class;
   GEnumValue *enum_value;
@@ -335,14 +387,30 @@ gimp_enum_get_value (GType         enum_type,
 
   if (enum_value)
     {
+      if (value_name)
+        *value_name = enum_value->value_name;
+
       if (value_nick)
         *value_nick = enum_value->value_nick;
 
-      if (value_name)
-        *value_name = (enum_value->value_name ?
-                       dgettext (gimp_type_get_translation_domain (enum_type),
-                                 enum_value->value_name) :
-                       NULL);
+      if (value_desc || value_help)
+        {
+          GimpEnumDesc *enum_desc;
+
+          enum_desc = gimp_enum_get_desc (enum_class, value);
+
+          if (value_desc)
+            *value_desc = ((enum_desc && enum_desc->value_desc) ?
+                           dgettext (gimp_type_get_translation_domain (enum_type),
+                                     enum_desc->value_desc) :
+                           NULL);
+
+          if (value_help)
+            *value_help = ((enum_desc && enum_desc->value_desc) ?
+                           dgettext (gimp_type_get_translation_domain (enum_type),
+                                     enum_desc->value_help) :
+                           NULL);
+        }
 
       return TRUE;
     }
@@ -351,25 +419,177 @@ gimp_enum_get_value (GType         enum_type,
 }
 
 /**
- * gimp_enum_value_get_name:
+ * gimp_flags_get_value:
+ * @flags_type: the #GType of registered flags
+ * @value:      an integer value
+ * @value_name: return location for the value's name (or %NULL)
+ * @value_nick: return location for the value's nick (or %NULL)
+ * @value_desc: return location for the value's translated desc (or %NULL)
+ * @value_help: return location for the value's translated help (or %NULL)
+ *
+ * Checks if @value is valid for the flags registered as @flags_type.
+ * If the value exists in that flags, its name, nick and its translated
+ * desc and help are returned (if @value_name, @value_nick, @value_desc
+ * and @value_help are not %NULL).
+ *
+ * Return value: %TRUE if @value is valid for the @flags_type,
+ *               %FALSE otherwise
+ *
+ * Since: GIMP 2.2
+ **/
+gboolean
+gimp_flags_get_value (GType         flags_type,
+                      guint         value,
+                      const gchar **value_name,
+                      const gchar **value_nick,
+                      const gchar **value_desc,
+                      const gchar **value_help)
+{
+  GFlagsClass *flags_class;
+  GFlagsValue *flags_value;
+
+  g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), FALSE);
+
+  flags_class = g_type_class_peek (flags_type);
+  flags_value = g_flags_get_first_value (flags_class, value);
+
+  if (flags_value)
+    {
+      if (value_name)
+        *value_name = flags_value->value_name;
+
+      if (value_nick)
+        *value_nick = flags_value->value_nick;
+
+      if (value_desc || value_help)
+        {
+          GimpFlagsDesc *flags_desc;
+
+          flags_desc = gimp_flags_get_first_desc (flags_class, value);
+
+          if (value_desc)
+            *value_desc = ((flags_desc && flags_desc->value_desc) ?
+                           dgettext (gimp_type_get_translation_domain (flags_type),
+                                     flags_desc->value_desc) :
+                           NULL);
+
+          if (value_help)
+            *value_help = ((flags_desc && flags_desc->value_desc) ?
+                           dgettext (gimp_type_get_translation_domain (flags_type),
+                                     flags_desc->value_help) :
+                           NULL);
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/**
+ * gimp_enum_value_get_desc:
  * @enum_class: a #GEnumClass
  * @enum_value: a #GEnumValue from @enum_class
  *
- * Retrieves the translated name for a given @enum_value.
+ * Retrieves the translated desc for a given @enum_value.
  *
- * Return value: the translated name of the enum value
+ * Return value: the translated desc of the enum value
  *
  * Since: GIMP 2.2
  **/
 const gchar *
-gimp_enum_value_get_name (GEnumClass *enum_class,
+gimp_enum_value_get_desc (GEnumClass *enum_class,
                           GEnumValue *enum_value)
 {
-  GType  type = G_TYPE_FROM_CLASS (enum_class);
+  GType         type = G_TYPE_FROM_CLASS (enum_class);
+  GimpEnumDesc *enum_desc;
 
-  if (enum_value->value_name)
+  enum_desc = gimp_enum_get_desc (enum_class, enum_value->value);
+
+  if (enum_desc->value_desc)
     return dgettext (gimp_type_get_translation_domain (type),
-                     enum_value->value_name);
+                     enum_desc->value_desc);
+
+  return enum_value->value_name;
+}
+
+/**
+ * gimp_enum_value_get_help:
+ * @enum_class: a #GEnumClass
+ * @enum_value: a #GEnumValue from @enum_class
+ *
+ * Retrieves the translated help for a given @enum_value.
+ *
+ * Return value: the translated help of the enum value
+ *
+ * Since: GIMP 2.2
+ **/
+const gchar *
+gimp_enum_value_get_help (GEnumClass *enum_class,
+                          GEnumValue *enum_value)
+{
+  GType         type = G_TYPE_FROM_CLASS (enum_class);
+  GimpEnumDesc *enum_desc;
+
+  enum_desc = gimp_enum_get_desc (enum_class, enum_value->value);
+
+  if (enum_desc->value_help)
+    return dgettext (gimp_type_get_translation_domain (type),
+                     enum_desc->value_help);
+
+  return NULL;
+}
+
+/**
+ * gimp_flags_value_get_desc:
+ * @flags_class: a #GFlagsClass
+ * @flags_value: a #GFlagsValue from @flags_class
+ *
+ * Retrieves the translated desc for a given @flags_value.
+ *
+ * Return value: the translated desc of the flags value
+ *
+ * Since: GIMP 2.2
+ **/
+const gchar *
+gimp_flags_value_get_desc (GFlagsClass *flags_class,
+                           GFlagsValue *flags_value)
+{
+  GType         type = G_TYPE_FROM_CLASS (flags_class);
+  GimpFlagsDesc *flags_desc;
+
+  flags_desc = gimp_flags_get_first_desc (flags_class, flags_value->value);
+
+  if (flags_desc->value_desc)
+    return dgettext (gimp_type_get_translation_domain (type),
+                     flags_desc->value_desc);
+
+  return flags_value->value_name;
+}
+
+/**
+ * gimp_flags_value_get_help:
+ * @flags_class: a #GFlagsClass
+ * @flags_value: a #GFlagsValue from @flags_class
+ *
+ * Retrieves the translated help for a given @flags_value.
+ *
+ * Return value: the translated help of the flags value
+ *
+ * Since: GIMP 2.2
+ **/
+const gchar *
+gimp_flags_value_get_help (GFlagsClass *flags_class,
+                           GFlagsValue *flags_value)
+{
+  GType         type = G_TYPE_FROM_CLASS (flags_class);
+  GimpFlagsDesc *flags_desc;
+
+  flags_desc = gimp_flags_get_first_desc (flags_class, flags_value->value);
+
+  if (flags_desc->value_help)
+    return dgettext (gimp_type_get_translation_domain (type),
+                     flags_desc->value_help);
 
   return NULL;
 }
diff --git a/libgimpbase/gimputils.h b/libgimpbase/gimputils.h
index 42ec2f2955..b5934986c4 100644
--- a/libgimpbase/gimputils.h
+++ b/libgimpbase/gimputils.h
@@ -21,23 +21,44 @@
 #define __GIMP_UTILS_H__
 
 
-gchar       * gimp_utf8_strtrim        (const gchar  *str,
-                                        gint          max_chars);
-gchar       * gimp_any_to_utf8         (const gchar  *str,
-                                        gssize        len,
-                                        const gchar  *warning_format,
-                                        ...) G_GNUC_PRINTF (3, 4);
-const gchar * gimp_filename_to_utf8    (const gchar  *filename);
+gchar         * gimp_utf8_strtrim         (const gchar  *str,
+                                           gint          max_chars);
+gchar         * gimp_any_to_utf8          (const gchar  *str,
+                                           gssize        len,
+                                           const gchar  *warning_format,
+                                           ...) G_GNUC_PRINTF (3, 4);
+const gchar   * gimp_filename_to_utf8     (const gchar  *filename);
 
-gchar       * gimp_strip_uline         (const gchar  *str);
-gchar       * gimp_escape_uline        (const gchar  *str);
+gchar         * gimp_strip_uline          (const gchar  *str);
+gchar         * gimp_escape_uline         (const gchar  *str);
 
-gboolean      gimp_enum_get_value      (GType         enum_type,
-                                        gint          value,
-                                        const gchar **value_nick,
-                                        const gchar **value_name);
-const gchar * gimp_enum_value_get_name (GEnumClass   *enum_class,
-                                        GEnumValue   *enum_value);
+GimpEnumDesc  * gimp_enum_get_desc        (GEnumClass   *enum_class,
+                                           gint          value);
+GimpFlagsDesc * gimp_flags_get_first_desc (GFlagsClass  *flags_class,
+                                           guint         value);
+
+gboolean        gimp_enum_get_value       (GType         enum_type,
+                                           gint          value,
+                                           const gchar **value_name,
+                                           const gchar **value_nick,
+                                           const gchar **value_desc,
+                                           const gchar **value_help);
+gboolean        gimp_flags_get_value      (GType         flags_type,
+                                           guint         value,
+                                           const gchar **value_name,
+                                           const gchar **value_nick,
+                                           const gchar **value_desc,
+                                           const gchar **value_help);
+
+const gchar   * gimp_enum_value_get_desc  (GEnumClass   *enum_class,
+                                           GEnumValue   *enum_value);
+const gchar   * gimp_enum_value_get_help  (GEnumClass   *enum_class,
+                                           GEnumValue   *enum_value);
+
+const gchar   * gimp_flags_value_get_desc (GFlagsClass  *flags_class,
+                                           GFlagsValue  *flags_value);
+const gchar   * gimp_flags_value_get_help (GFlagsClass  *flags_class,
+                                           GFlagsValue  *flags_value);
 
 
 #endif  /* __GIMP_UTILS_H__ */
diff --git a/libgimpwidgets/gimpenumstore.c b/libgimpwidgets/gimpenumstore.c
index 6a04db41a1..a700485639 100644
--- a/libgimpwidgets/gimpenumstore.c
+++ b/libgimpwidgets/gimpenumstore.c
@@ -96,14 +96,14 @@ gimp_enum_store_add_value (GtkListStore *store,
                            GEnumValue   *value)
 {
   GtkTreeIter  iter;
-  const gchar *name;
+  const gchar *desc;
 
-  name = gimp_enum_value_get_name (GIMP_ENUM_STORE (store)->enum_class, value);
+  desc = gimp_enum_value_get_desc (GIMP_ENUM_STORE (store)->enum_class, value);
 
   gtk_list_store_append (store, &iter);
   gtk_list_store_set (store, &iter,
                       GIMP_INT_STORE_VALUE, value->value,
-                      GIMP_INT_STORE_LABEL, name,
+                      GIMP_INT_STORE_LABEL, desc,
                       -1);
 }
 
diff --git a/libgimpwidgets/gimpenumwidgets.c b/libgimpwidgets/gimpenumwidgets.c
index ba8b55fcb2..b609a8efcf 100644
--- a/libgimpwidgets/gimpenumwidgets.c
+++ b/libgimpwidgets/gimpenumwidgets.c
@@ -95,14 +95,14 @@ gimp_enum_radio_box_new_with_range (GType       enum_type,
 
   for (value = enum_class->values; value->value_name; value++)
     {
-      const gchar *name;
+      const gchar *desc;
 
       if (value->value < minimum || value->value > maximum)
         continue;
 
-      name = gimp_enum_value_get_name (enum_class, value);
+      desc = gimp_enum_value_get_desc (enum_class, value);
 
-      button = gtk_radio_button_new_with_mnemonic (group, name);
+      button = gtk_radio_button_new_with_mnemonic (group, desc);
 
       if (first_button && *first_button == NULL)
         *first_button = button;
@@ -303,7 +303,7 @@ gimp_enum_stock_box_new_with_range (GType         enum_type,
         }
 
       gimp_help_set_help_data (button,
-                               gimp_enum_value_get_name (enum_class, value),
+                               gimp_enum_value_get_desc (enum_class, value),
                                NULL);
 
       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
diff --git a/libgimpwidgets/gimppreviewarea.c b/libgimpwidgets/gimppreviewarea.c
index 4625b2f2db..dddc57f8b2 100644
--- a/libgimpwidgets/gimppreviewarea.c
+++ b/libgimpwidgets/gimppreviewarea.c
@@ -1741,7 +1741,7 @@ gimp_preview_area_menu_new (GimpPreviewArea *area,
 
   for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
     {
-      const gchar *name = gimp_enum_value_get_name (enum_class, enum_value);
+      const gchar *name = gimp_enum_value_get_desc (enum_class, enum_value);
 
       item = gtk_radio_menu_item_new_with_label (group, name);
 
diff --git a/tools/gimp-mkenums b/tools/gimp-mkenums
index 4f45e23f29..72ab81206e 100755
--- a/tools/gimp-mkenums
+++ b/tools/gimp-mkenums
@@ -109,7 +109,7 @@ sub parse_entries {
 	    if (defined $options) {
 		my %options = parse_trigraph($options);
 		if (!defined $options{"skip"}) {
-		    push @entries, [ $name, $options{nick}, $options{desc} ];
+		    push @entries, [ $name, $options{nick}, $options{desc}, $options{help} ];
 		}
 	    } else {
 		push @entries, [ $name ];
@@ -141,6 +141,9 @@ sub usage {
     print STDERR "  --vhead <text>             value header, produced before iterating over enum values\n";
     print STDERR "  --vprod <text>             value text, produced for each enum value\n";
     print STDERR "  --vtail <text>             value tail, produced after iterating over enum values\n";
+    print STDERR "  --dhead <text>             description header, produced before iterating over enum value descriptions\n";
+    print STDERR "  --dprod <text>             description text, produced for each enum value description\n";
+    print STDERR "  --dtail <text>             description tail, produced after iterating over enum value descriptions\n";
     print STDERR "  --comments <text>          comment structure\n";
     print STDERR "  -h, --help                 show this help message\n";
     print STDERR "  -v, --version              print version informations\n";
@@ -152,6 +155,7 @@ sub usage {
     print STDERR "  \@VALUENAME\@                PREFIX_THE_XVALUE\n";
     print STDERR "  \@valuenick\@                the-xvalue\n";
     print STDERR "  \@valuedesc\@                descriptions as defined in the header\n";
+    print STDERR "  \@valuehelp\@                help texts as defined in the header\n";
     print STDERR "  \@type\@                     either enum or flags\n";
     print STDERR "  \@Type\@                     either Enum or Flags\n";
     print STDERR "  \@TYPE\@                     either ENUM or FLAGS\n";
@@ -167,6 +171,9 @@ my $eprod = "";   # per enum text (produced prior to value itarations)
 my $vhead = "";   # value header, produced before iterating over enum values
 my $vprod = "";   # value text, produced for each enum value
 my $vtail = "";   # value tail, produced after iterating over enum values
+my $dhead = "";   # desc header, produced before iterating over enum values
+my $dprod = "";   # desc text, produced for each enum value
+my $dtail = "";   # desc tail, produced after iterating over enum values
 # other options
 my $comment_tmpl = "/* \@comment\@ */";
 
@@ -183,6 +190,9 @@ while ($_ = $ARGV[0], /^-/) {
     elsif (/^--vhead$/)              { $vhead = $vhead . shift }
     elsif (/^--vprod$/)              { $vprod = $vprod . shift }
     elsif (/^--vtail$/)              { $vtail = $vtail . shift }
+    elsif (/^--dhead$/)              { $dhead = $dhead . shift }
+    elsif (/^--dprod$/)              { $dprod = $dprod . shift }
+    elsif (/^--dtail$/)              { $dtail = $dtail . shift }
     elsif (/^--comments$/)           { $comment_tmpl = shift }
     elsif (/^--help$/ || /^-h$/)     { usage; }
     elsif (/^--version$/ || /^-v$/)  { version; }
@@ -289,7 +299,7 @@ while (<>) {
 	}
 	
 	for $entry (@entries) {
-	    my ($name,$nick,$desc) = @{$entry};
+	    my ($name,$nick,$desc,$help) = @{$entry};
             if (!defined $nick) {
  	        ($nick = $name) =~ s/^$enum_prefix//;
 	        $nick =~ tr/_/-/;
@@ -300,7 +310,12 @@ while (<>) {
 	    } else {
 		$desc = "N_($desc)";
 	    }
-	    @{$entry} = ($name, $nick, $desc);
+	    if (!defined $help) {
+		$help = "NULL";
+	    } else {
+		$help = "N_($help)";
+	    }
+	    @{$entry} = ($name, $nick, $desc, $help);
 	}
 	
 
@@ -376,12 +391,13 @@ while (<>) {
 	    $prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
 	    $prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
 	    for (@entries) {
-		my ($name,$nick,$desc) = @{$_};
+		my ($name,$nick,$desc,$help) = @{$_};
 		my $tmp_prod = $prod;
 
 		$tmp_prod =~ s/\@VALUENAME\@/$name/g;
 		$tmp_prod =~ s/\@valuenick\@/$nick/g;
 		$tmp_prod =~ s/\@valuedesc\@/$desc/g;
+		$tmp_prod =~ s/\@valuehelp\@/$help/g;
 		if ($flags) { $tmp_prod =~ s/\@type\@/flags/g; } else { $tmp_prod =~ s/\@type\@/enum/g; }
 		if ($flags) { $tmp_prod =~ s/\@Type\@/Flags/g; } else { $tmp_prod =~ s/\@Type\@/Enum/g; }
 		if ($flags) { $tmp_prod =~ s/\@TYPE\@/FLAGS/g; } else { $tmp_prod =~ s/\@TYPE\@/ENUM/g; }
@@ -405,6 +421,59 @@ while (<>) {
 	    
             print "$prod\n";
 	}
+
+	if (length($dhead)) {
+	    my $prod = $dhead;
+
+	    $prod =~ s/\@enum_name\@/$enumsym/g;
+            $prod =~ s/\@EnumName\@/$enumname/g;
+            $prod =~ s/\@ENUMSHORT\@/$enumshort/g;
+            $prod =~ s/\@ENUMNAME\@/$enumlong/g;
+	    if ($flags) { $prod =~ s/\@type\@/flags/g; } else { $prod =~ s/\@type\@/enum/g; }
+	    if ($flags) { $prod =~ s/\@Type\@/Flags/g; } else { $prod =~ s/\@Type\@/Enum/g; }
+	    if ($flags) { $prod =~ s/\@TYPE\@/FLAGS/g; } else { $prod =~ s/\@TYPE\@/ENUM/g; }
+            $prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
+            $prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
+	    
+            print "$prod\n";
+	}
+
+	if (length($dprod)) {
+	    my $prod = $dprod;
+	    
+	    $prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
+	    $prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
+	    for (@entries) {
+		my ($name,$nick,$desc,$help) = @{$_};
+		my $tmp_prod = $prod;
+
+		$tmp_prod =~ s/\@VALUENAME\@/$name/g;
+		$tmp_prod =~ s/\@valuenick\@/$nick/g;
+		$tmp_prod =~ s/\@valuedesc\@/$desc/g;
+		$tmp_prod =~ s/\@valuehelp\@/$help/g;
+		if ($flags) { $tmp_prod =~ s/\@type\@/flags/g; } else { $tmp_prod =~ s/\@type\@/enum/g; }
+		if ($flags) { $tmp_prod =~ s/\@Type\@/Flags/g; } else { $tmp_prod =~ s/\@Type\@/Enum/g; }
+		if ($flags) { $tmp_prod =~ s/\@TYPE\@/FLAGS/g; } else { $tmp_prod =~ s/\@TYPE\@/ENUM/g; }
+
+		print "$tmp_prod\n";
+	    }
+	}
+
+	if (length($dtail)) {
+	    my $prod = $dtail;
+
+	    $prod =~ s/\@enum_name\@/$enumsym/g;
+            $prod =~ s/\@EnumName\@/$enumname/g;
+            $prod =~ s/\@ENUMSHORT\@/$enumshort/g;
+            $prod =~ s/\@ENUMNAME\@/$enumlong/g;
+	    if ($flags) { $prod =~ s/\@type\@/flags/g; } else { $prod =~ s/\@type\@/enum/g; }
+	    if ($flags) { $prod =~ s/\@Type\@/Flags/g; } else { $prod =~ s/\@Type\@/Enum/g; }
+	    if ($flags) { $prod =~ s/\@TYPE\@/FLAGS/g; } else { $prod =~ s/\@TYPE\@/ENUM/g; }
+            $prod =~ s/\\a/\a/g; $prod =~ s/\\b/\b/g; $prod =~ s/\\t/\t/g; $prod =~ s/\\n/\n/g;
+            $prod =~ s/\\f/\f/g; $prod =~ s/\\r/\r/g;
+	    
+            print "$prod\n";
+	}
     }
 }