diff --git a/libgimpcolor/gimprgb.c b/libgimpcolor/gimprgb.c
index b6ad3e245d..209a502160 100644
--- a/libgimpcolor/gimprgb.c
+++ b/libgimpcolor/gimprgb.c
@@ -702,6 +702,8 @@ gimp_param_rgb_validate (GParamSpec *pspec,
 {
   GimpRGB *rgb = value->data[0].v_pointer;
 
+  return FALSE;
+
   if (rgb)
     {
       GimpRGB oval = *rgb;
diff --git a/libgimpwidgets/gimpcolorscale.c b/libgimpwidgets/gimpcolorscale.c
index 4064659688..c88ac3f428 100644
--- a/libgimpwidgets/gimpcolorscale.c
+++ b/libgimpwidgets/gimpcolorscale.c
@@ -54,6 +54,14 @@ enum
 };
 
 
+typedef struct _GimpLCH  GimpLCH;
+
+struct _GimpLCH
+{
+  gdouble l, c, h, a;
+};
+
+
 typedef struct _GimpColorScalePrivate GimpColorScalePrivate;
 
 struct _GimpColorScalePrivate
@@ -104,6 +112,9 @@ G_DEFINE_TYPE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE)
 
 #define parent_class gimp_color_scale_parent_class
 
+static const Babl *fish_rgb_to_lch = NULL;
+static const Babl *fish_lch_to_rgb = NULL;
+
 
 static void
 gimp_color_scale_class_init (GimpColorScaleClass *klass)
@@ -138,6 +149,11 @@ gimp_color_scale_class_init (GimpColorScaleClass *klass)
                                                       G_PARAM_CONSTRUCT));
 
   g_type_class_add_private (object_class, sizeof (GimpColorScalePrivate));
+
+  fish_rgb_to_lch = babl_fish (babl_format ("R'G'B'A double"),
+                               babl_format ("CIE LCH(ab) double"));
+  fish_lch_to_rgb = babl_fish (babl_format ("CIE LCH(ab) double"),
+                               babl_format ("R'G'B' double"));
 }
 
 static void
@@ -756,9 +772,12 @@ gimp_color_scale_render (GimpColorScale *scale)
   GtkRange *range = GTK_RANGE (scale);
   GimpRGB   rgb;
   GimpHSV   hsv;
+  GimpLCH   lch;
+  gint      multiplier = 1;
   guint     x, y;
   gdouble  *channel_value = NULL; /* shut up compiler */
-  gboolean  to_rgb        = FALSE;
+  gboolean  from_hsv      = FALSE;
+  gboolean  from_lch      = FALSE;
   gboolean  invert;
   guchar   *buf;
   guchar   *d;
@@ -774,16 +793,22 @@ gimp_color_scale_render (GimpColorScale *scale)
 
   rgb = scale->rgb;
   hsv = scale->hsv;
+  babl_process (fish_rgb_to_lch, &rgb, &lch, 1);
 
   switch (scale->channel)
     {
     case GIMP_COLOR_SELECTOR_HUE:        channel_value = &hsv.h; break;
     case GIMP_COLOR_SELECTOR_SATURATION: channel_value = &hsv.s; break;
     case GIMP_COLOR_SELECTOR_VALUE:      channel_value = &hsv.v; break;
+
     case GIMP_COLOR_SELECTOR_RED:        channel_value = &rgb.r; break;
     case GIMP_COLOR_SELECTOR_GREEN:      channel_value = &rgb.g; break;
     case GIMP_COLOR_SELECTOR_BLUE:       channel_value = &rgb.b; break;
     case GIMP_COLOR_SELECTOR_ALPHA:      channel_value = &rgb.a; break;
+
+    case GIMP_COLOR_SELECTOR_LCH_LIGHTNESS: channel_value = &lch.l; break;
+    case GIMP_COLOR_SELECTOR_LCH_CHROMA:    channel_value = &lch.c; break;
+    case GIMP_COLOR_SELECTOR_LCH_HUE:       channel_value = &lch.h; break;
     }
 
   switch (scale->channel)
@@ -791,7 +816,20 @@ gimp_color_scale_render (GimpColorScale *scale)
     case GIMP_COLOR_SELECTOR_HUE:
     case GIMP_COLOR_SELECTOR_SATURATION:
     case GIMP_COLOR_SELECTOR_VALUE:
-      to_rgb = TRUE;
+      from_hsv = TRUE;
+      break;
+
+    case GIMP_COLOR_SELECTOR_LCH_LIGHTNESS:
+      multiplier = 100;
+      from_lch = TRUE;
+      break;
+    case GIMP_COLOR_SELECTOR_LCH_CHROMA:
+      multiplier = 100;
+      from_lch = TRUE;
+      break;
+    case GIMP_COLOR_SELECTOR_LCH_HUE:
+      multiplier = 360;
+      from_lch = TRUE;
       break;
 
     default:
@@ -805,18 +843,39 @@ gimp_color_scale_render (GimpColorScale *scale)
     case GTK_ORIENTATION_HORIZONTAL:
       for (x = 0, d = buf; x < scale->width; x++, d += 4)
         {
-          gdouble value = (gdouble) x / (gdouble) (scale->width - 1);
+          gdouble value = (gdouble) x * multiplier / (gdouble) (scale->width - 1);
           guchar  r, g, b;
 
           if (invert)
-            value = 1.0 - value;
+            value = multiplier - value;
 
           *channel_value = value;
 
-          if (to_rgb)
+          if (from_hsv)
             gimp_hsv_to_rgb (&hsv, &rgb);
+          else if (from_lch)
+            babl_process (fish_lch_to_rgb, &lch, &rgb, 1);
 
-          gimp_rgb_get_uchar (&rgb, &r, &g, &b);
+          if (rgb.r < 0.0 ||
+              rgb.g < 0.0 ||
+              rgb.b < 0.0)
+            {
+              r = 255;
+              g = 255;
+              b = 255;
+            }
+          else if (rgb.r > 1.0 ||
+                   rgb.g > 1.0 ||
+                   rgb.b > 1.0)
+            {
+              r = 0;
+              g = 0;
+              b = 0;
+            }
+          else
+            {
+              gimp_rgb_get_uchar (&rgb, &r, &g, &b);
+            }
 
           GIMP_CAIRO_RGB24_SET_PIXEL (d, r, g, b);
         }
@@ -832,18 +891,39 @@ gimp_color_scale_render (GimpColorScale *scale)
     case GTK_ORIENTATION_VERTICAL:
       for (y = 0; y < scale->height; y++)
         {
-          gdouble value = (gdouble) y / (gdouble) (scale->height - 1);
+          gdouble value = (gdouble) y * multiplier / (gdouble) (scale->height - 1);
           guchar  r, g, b;
 
           if (invert)
-            value = 1.0 - value;
+            value = multiplier - value;
 
           *channel_value = value;
 
-          if (to_rgb)
+          if (from_hsv)
             gimp_hsv_to_rgb (&hsv, &rgb);
+          else if (from_lch)
+            babl_process (fish_lch_to_rgb, &lch, &rgb, 1);
 
-          gimp_rgb_get_uchar (&rgb, &r, &g, &b);
+          if (rgb.r < 0.0 ||
+              rgb.g < 0.0 ||
+              rgb.b < 0.0)
+            {
+              r = 255;
+              g = 255;
+              b = 255;
+            }
+          else if (rgb.r > 1.0 ||
+                   rgb.g > 1.0 ||
+                   rgb.b > 1.0)
+            {
+              r = 0;
+              g = 0;
+              b = 0;
+            }
+          else
+            {
+              gimp_rgb_get_uchar (&rgb, &r, &g, &b);
+            }
 
           for (x = 0, d = buf; x < scale->width; x++, d += 4)
             {
diff --git a/libgimpwidgets/gimpcolorscales.c b/libgimpwidgets/gimpcolorscales.c
index c583f3c9ab..2ba3596a69 100644
--- a/libgimpwidgets/gimpcolorscales.c
+++ b/libgimpwidgets/gimpcolorscales.c
@@ -49,10 +49,18 @@
  *
  * The #GimpColorScales widget is an implementation of a
  * #GimpColorSelector. It shows a group of #GimpColorScale widgets
- * that allow to adjust the HSV and RGB color channels.
+ * that allow to adjust the HSV, LCH, and RGB color channels.
  **/
 
 
+typedef struct _GimpLCH  GimpLCH;
+
+struct _GimpLCH
+{
+  gdouble l, c, h, a;
+};
+
+
 #define GIMP_COLOR_SCALES_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_SCALES, GimpColorScalesClass))
 #define GIMP_IS_COLOR_SCALES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_SCALES))
 #define GIMP_COLOR_SCALES_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_SCALES, GimpColorScalesClass))
@@ -64,9 +72,9 @@ struct _GimpColorScales
 {
   GimpColorSelector  parent_instance;
 
-  GtkWidget         *toggles[7];
-  GtkWidget         *sliders[7];
-  GtkObject         *slider_data[7];
+  GtkWidget         *toggles[10];
+  GtkWidget         *sliders[10];
+  GtkObject         *slider_data[10];
 };
 
 struct _GimpColorScalesClass
@@ -102,6 +110,9 @@ G_DEFINE_TYPE (GimpColorScales, gimp_color_scales, GIMP_TYPE_COLOR_SELECTOR)
 
 #define parent_class gimp_color_scales_parent_class
 
+static const Babl *fish_rgb_to_lch = NULL;
+static const Babl *fish_lch_to_rgb = NULL;
+
 
 static void
 gimp_color_scales_class_init (GimpColorScalesClass *klass)
@@ -117,6 +128,11 @@ gimp_color_scales_class_init (GimpColorScalesClass *klass)
   selector_class->set_color             = gimp_color_scales_set_color;
   selector_class->set_channel           = gimp_color_scales_set_channel;
   selector_class->set_config            = gimp_color_scales_set_config;
+
+  fish_rgb_to_lch = babl_fish (babl_format ("R'G'B'A double"),
+                               babl_format ("CIE LCH(ab) double"));
+  fish_lch_to_rgb = babl_fish (babl_format ("CIE LCH(ab) double"),
+                               babl_format ("R'G'B' double"));
 }
 
 static void
@@ -129,19 +145,21 @@ gimp_color_scales_init (GimpColorScales *scales)
   gint               i;
 
   static const gdouble slider_initial_vals[] =
-    {   0,   0,   0,   0,   0,   0,   0 };
+  /*{   H,   S,   V,   R,   G,   B,   A,   L,   C,   H }*/
+    {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 };
   static const gdouble slider_max_vals[] =
-    { 360, 100, 100, 100, 100, 100, 100 };
+    { 360, 100, 100, 100, 100, 100, 100, 100, 100, 360 };
   static const gdouble slider_incs[] =
-    {  30,  10,  10,  16,  16,  16,  10 };
+    {  30,  10,  10,  16,  16,  16,  10,  10,  10,  30 };
 
   /*  don't needs the toggles for our own operation  */
   selector->toggles_visible = FALSE;
 
-  table = gtk_table_new (7, 4, FALSE);
+  table = gtk_table_new (11, 4, FALSE);
   gtk_table_set_row_spacings (GTK_TABLE (table), 1);
-  gtk_table_set_row_spacing (GTK_TABLE (table), 2, 5); /* hsv <-> rgb   */
-  gtk_table_set_row_spacing (GTK_TABLE (table), 5, 5); /* rgb <-> alpha */
+  gtk_table_set_row_spacing (GTK_TABLE (table), 2, 5); /* hsv   <-> rgb   */
+  gtk_table_set_row_spacing (GTK_TABLE (table), 5, 5); /* rgb   <-> alpha */
+  gtk_table_set_row_spacing (GTK_TABLE (table), 6, 5); /* alpha <-> lch   */
   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 0);
   gtk_box_pack_start (GTK_BOX (scales), table, FALSE, FALSE, 0);
@@ -151,11 +169,9 @@ gimp_color_scales_init (GimpColorScales *scales)
 
   group = NULL;
 
-  for (i = GIMP_COLOR_SELECTOR_HUE; i <= GIMP_COLOR_SELECTOR_ALPHA; i++)
+  for (i = 0; i < 10; i++)
     {
-      GimpEnumDesc *enum_desc;
-
-      enum_desc = gimp_enum_get_desc (enum_class, i);
+      GimpEnumDesc *enum_desc = gimp_enum_get_desc (enum_class, i);
 
       if (i == GIMP_COLOR_SELECTOR_ALPHA)
         {
@@ -212,8 +228,9 @@ gimp_color_scales_togg_sensitive (GimpColorSelector *selector,
   GimpColorScales *scales = GIMP_COLOR_SCALES (selector);
   gint             i;
 
-  for (i = 0; i < 6; i++)
-    gtk_widget_set_sensitive (scales->toggles[i], sensitive);
+  for (i = 0; i < 10; i++)
+    if (scales->toggles[i])
+      gtk_widget_set_sensitive (scales->toggles[i], sensitive);
 }
 
 static void
@@ -223,8 +240,9 @@ gimp_color_scales_togg_visible (GimpColorSelector *selector,
   GimpColorScales *scales = GIMP_COLOR_SCALES (selector);
   gint             i;
 
-  for (i = 0; i < 6; i++)
-    gtk_widget_set_visible (scales->toggles[i], visible);
+  for (i = 0; i < 10; i++)
+    if (scales->toggles[i])
+      gtk_widget_set_visible (scales->toggles[i], visible);
 }
 
 static void
@@ -269,7 +287,7 @@ gimp_color_scales_set_channel (GimpColorSelector        *selector,
 {
   GimpColorScales *scales = GIMP_COLOR_SCALES (selector);
 
-  if (channel < 7)
+  if (scales->toggles[channel])
     {
       g_signal_handlers_block_by_func (scales->toggles[channel],
                                        gimp_color_scales_toggle_update,
@@ -291,7 +309,7 @@ gimp_color_scales_set_config (GimpColorSelector *selector,
   GimpColorScales *scales = GIMP_COLOR_SCALES (selector);
   gint             i;
 
-  for (i = 0; i < 7; i++)
+  for (i = 0; i < 10; i++)
     {
       if (scales->sliders[i])
         gimp_color_scale_set_color_config (GIMP_COLOR_SCALE (scales->sliders[i]),
@@ -304,18 +322,26 @@ gimp_color_scales_update_scales (GimpColorScales *scales,
                                  gint             skip)
 {
   GimpColorSelector *selector = GIMP_COLOR_SELECTOR (scales);
-  gint               values[7];
+  GimpLCH            lch;
+  gdouble            values[10];
   gint               i;
 
-  values[GIMP_COLOR_SELECTOR_HUE]        = ROUND (selector->hsv.h * 360.0);
-  values[GIMP_COLOR_SELECTOR_SATURATION] = ROUND (selector->hsv.s * 100.0);
-  values[GIMP_COLOR_SELECTOR_VALUE]      = ROUND (selector->hsv.v * 100.0);
-  values[GIMP_COLOR_SELECTOR_RED]        = ROUND (selector->rgb.r * 100.0);
-  values[GIMP_COLOR_SELECTOR_GREEN]      = ROUND (selector->rgb.g * 100.0);
-  values[GIMP_COLOR_SELECTOR_BLUE]       = ROUND (selector->rgb.b * 100.0);
-  values[GIMP_COLOR_SELECTOR_ALPHA]      = ROUND (selector->rgb.a * 100.0);
+  babl_process (fish_rgb_to_lch, &selector->rgb, &lch, 1);
+
+  values[GIMP_COLOR_SELECTOR_HUE]           = selector->hsv.h * 360.0;
+  values[GIMP_COLOR_SELECTOR_SATURATION]    = selector->hsv.s * 100.0;
+  values[GIMP_COLOR_SELECTOR_VALUE]         = selector->hsv.v * 100.0;
+
+  values[GIMP_COLOR_SELECTOR_RED]           = selector->rgb.r * 100.0;
+  values[GIMP_COLOR_SELECTOR_GREEN]         = selector->rgb.g * 100.0;
+  values[GIMP_COLOR_SELECTOR_BLUE]          = selector->rgb.b * 100.0;
+  values[GIMP_COLOR_SELECTOR_ALPHA]         = selector->rgb.a * 100.0;
 
-  for (i = 0; i < 7; i++)
+  values[GIMP_COLOR_SELECTOR_LCH_LIGHTNESS] = lch.l;
+  values[GIMP_COLOR_SELECTOR_LCH_CHROMA]    = lch.c;
+  values[GIMP_COLOR_SELECTOR_LCH_HUE]       = lch.h;
+
+for (i = 0; i < 10; i++)
     {
       if (i != skip)
         {
@@ -346,7 +372,7 @@ gimp_color_scales_toggle_update (GtkWidget       *widget,
     {
       gint i;
 
-      for (i = 0; i < 6; i++)
+      for (i = 0; i < 10; i++)
         if (widget == scales->toggles[i])
           {
             selector->channel = (GimpColorSelectorChannel) i;
@@ -363,9 +389,10 @@ gimp_color_scales_scale_update (GtkAdjustment   *adjustment,
 {
   GimpColorSelector *selector = GIMP_COLOR_SELECTOR (scales);
   gdouble            value    = gtk_adjustment_get_value (adjustment);
+  GimpLCH            lch;
   gint               i;
 
-  for (i = 0; i < 7; i++)
+  for (i = 0; i < 10; i++)
     if (scales->slider_data[i] == GTK_OBJECT (adjustment))
       break;
 
@@ -398,13 +425,36 @@ gimp_color_scales_scale_update (GtkAdjustment   *adjustment,
     case GIMP_COLOR_SELECTOR_ALPHA:
       selector->hsv.a = selector->rgb.a = value / 100.0;
       break;
+
+    case GIMP_COLOR_SELECTOR_LCH_LIGHTNESS:
+      babl_process (fish_rgb_to_lch, &selector->rgb, &lch, 1);
+      lch.l = value;
+      break;
+
+    case GIMP_COLOR_SELECTOR_LCH_CHROMA:
+      babl_process (fish_rgb_to_lch, &selector->rgb, &lch, 1);
+      lch.c = value;
+      break;
+
+    case GIMP_COLOR_SELECTOR_LCH_HUE:
+      babl_process (fish_rgb_to_lch, &selector->rgb, &lch, 1);
+      lch.h = value;
+      break;
     }
 
-  if ((i >= GIMP_COLOR_SELECTOR_HUE) && (i <= GIMP_COLOR_SELECTOR_VALUE))
+  if ((i >= GIMP_COLOR_SELECTOR_HUE) &&
+      (i <= GIMP_COLOR_SELECTOR_VALUE))
     {
       gimp_hsv_to_rgb (&selector->hsv, &selector->rgb);
     }
-  else if ((i >= GIMP_COLOR_SELECTOR_RED) && (i <= GIMP_COLOR_SELECTOR_BLUE))
+  else if ((i >= GIMP_COLOR_SELECTOR_LCH_LIGHTNESS) &&
+           (i <= GIMP_COLOR_SELECTOR_LCH_HUE))
+    {
+      babl_process (fish_lch_to_rgb, &lch, &selector->rgb, 1);
+      gimp_rgb_to_hsv (&selector->rgb, &selector->hsv);
+    }
+  else if ((i >= GIMP_COLOR_SELECTOR_RED) &&
+           (i <= GIMP_COLOR_SELECTOR_BLUE))
     {
       gimp_rgb_to_hsv (&selector->rgb, &selector->hsv);
     }
diff --git a/libgimpwidgets/gimpcolorselect.c b/libgimpwidgets/gimpcolorselect.c
index cbf1d928a1..684cee5c6f 100644
--- a/libgimpwidgets/gimpcolorselect.c
+++ b/libgimpwidgets/gimpcolorselect.c
@@ -69,16 +69,27 @@ typedef enum
   COLOR_SELECT_HUE = 0,
   COLOR_SELECT_SATURATION,
   COLOR_SELECT_VALUE,
+
   COLOR_SELECT_RED,
   COLOR_SELECT_GREEN,
   COLOR_SELECT_BLUE,
   COLOR_SELECT_ALPHA,
+
+  COLOR_SELECT_LCH_LIGHTNESS,
+  COLOR_SELECT_LCH_CHROMA,
+  COLOR_SELECT_LCH_HUE,
+
   COLOR_SELECT_HUE_SATURATION,
   COLOR_SELECT_HUE_VALUE,
   COLOR_SELECT_SATURATION_VALUE,
+
   COLOR_SELECT_RED_GREEN,
   COLOR_SELECT_RED_BLUE,
-  COLOR_SELECT_GREEN_BLUE
+  COLOR_SELECT_GREEN_BLUE,
+
+  COLOR_SELECT_LCH_HUE_CHROMA,
+  COLOR_SELECT_LCH_HUE_LIGHTNESS,
+  COLOR_SELECT_LCH_CHROMA_LIGHTNESS
 } ColorSelectFillType;
 
 typedef enum
@@ -98,6 +109,14 @@ typedef enum
 } ColorSelectDragMode;
 
 
+typedef struct _GimpLCH  GimpLCH;
+
+struct _GimpLCH
+{
+  gdouble l, c, h, a;
+};
+
+
 #define GIMP_COLOR_SELECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_SELECT, GimpColorSelectClass))
 #define GIMP_IS_COLOR_SELECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_SELECT))
 #define GIMP_COLOR_SELECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_SELECT, GimpColorSelectClass))
@@ -114,6 +133,9 @@ struct _GimpColorSelect
   GtkWidget           *xy_color;
   GtkWidget           *z_color;
 
+  gboolean             xy_color_needs_render;
+  gboolean             z_color_needs_render;
+
   gdouble              pos[3];
 
   ColorSelectFillType  z_color_fill;
@@ -140,6 +162,7 @@ struct _ColorSelectFill
   gint     height;
   GimpRGB  rgb;
   GimpHSV  hsv;
+  GimpLCH  lch;
 
   ColorSelectFillUpdateProc update;
 };
@@ -192,23 +215,34 @@ static gboolean   gimp_color_select_z_events    (GtkWidget          *widget,
                                                  GdkEvent           *event,
                                                  GimpColorSelect    *select);
 
-static void   gimp_color_select_image_fill      (GtkWidget          *widget,
+static void   gimp_color_select_render          (GtkWidget          *widget,
                                                  ColorSelectFillType fill_type,
                                                  const GimpHSV      *hsv,
                                                  const GimpRGB      *rgb);
 
-static void   color_select_update_red              (ColorSelectFill *csf);
-static void   color_select_update_green            (ColorSelectFill *csf);
-static void   color_select_update_blue             (ColorSelectFill *csf);
-static void   color_select_update_hue              (ColorSelectFill *csf);
-static void   color_select_update_saturation       (ColorSelectFill *csf);
-static void   color_select_update_value            (ColorSelectFill *csf);
-static void   color_select_update_red_green        (ColorSelectFill *csf);
-static void   color_select_update_red_blue         (ColorSelectFill *csf);
-static void   color_select_update_green_blue       (ColorSelectFill *csf);
-static void   color_select_update_hue_saturation   (ColorSelectFill *csf);
-static void   color_select_update_hue_value        (ColorSelectFill *csf);
-static void   color_select_update_saturation_value (ColorSelectFill *csf);
+static void   color_select_render_red              (ColorSelectFill *csf);
+static void   color_select_render_green            (ColorSelectFill *csf);
+static void   color_select_render_blue             (ColorSelectFill *csf);
+
+static void   color_select_render_hue              (ColorSelectFill *csf);
+static void   color_select_render_saturation       (ColorSelectFill *csf);
+static void   color_select_render_value            (ColorSelectFill *csf);
+
+static void   color_select_render_lch_lightness    (ColorSelectFill *csf);
+static void   color_select_render_lch_chroma       (ColorSelectFill *csf);
+static void   color_select_render_lch_hue          (ColorSelectFill *csf);
+
+static void   color_select_render_red_green        (ColorSelectFill *csf);
+static void   color_select_render_red_blue         (ColorSelectFill *csf);
+static void   color_select_render_green_blue       (ColorSelectFill *csf);
+
+static void   color_select_render_hue_saturation   (ColorSelectFill *csf);
+static void   color_select_render_hue_value        (ColorSelectFill *csf);
+static void   color_select_render_saturation_value (ColorSelectFill *csf);
+
+static void   color_select_render_lch_chroma_lightness (ColorSelectFill *csf);
+static void   color_select_render_lch_hue_lightness    (ColorSelectFill *csf);
+static void   color_select_render_lch_hue_chroma       (ColorSelectFill *csf);
 
 
 G_DEFINE_TYPE (GimpColorSelect, gimp_color_select, GIMP_TYPE_COLOR_SELECTOR)
@@ -217,21 +251,36 @@ G_DEFINE_TYPE (GimpColorSelect, gimp_color_select, GIMP_TYPE_COLOR_SELECTOR)
 
 static const ColorSelectFillUpdateProc update_procs[] =
 {
-  color_select_update_hue,
-  color_select_update_saturation,
-  color_select_update_value,
-  color_select_update_red,
-  color_select_update_green,
-  color_select_update_blue,
+  color_select_render_hue,
+  color_select_render_saturation,
+  color_select_render_value,
+
+  color_select_render_red,
+  color_select_render_green,
+  color_select_render_blue,
   NULL, /* alpha */
-  color_select_update_hue_saturation,
-  color_select_update_hue_value,
-  color_select_update_saturation_value,
-  color_select_update_red_green,
-  color_select_update_red_blue,
-  color_select_update_green_blue,
+
+  color_select_render_lch_lightness,
+  color_select_render_lch_chroma,
+  color_select_render_lch_hue,
+
+  color_select_render_hue_saturation,
+  color_select_render_hue_value,
+  color_select_render_saturation_value,
+
+  color_select_render_red_green,
+  color_select_render_red_blue,
+  color_select_render_green_blue,
+
+  color_select_render_lch_hue_chroma,
+  color_select_render_lch_hue_lightness,
+  color_select_render_lch_chroma_lightness
 };
 
+static const Babl *fish_rgb_to_lch    = NULL;
+static const Babl *fish_lch_to_rgb    = NULL;
+static const Babl *fish_lch_to_rgb_u8 = NULL;
+
 
 static void
 gimp_color_select_class_init (GimpColorSelectClass *klass)
@@ -246,13 +295,21 @@ gimp_color_select_class_init (GimpColorSelectClass *klass)
   selector_class->set_color             = gimp_color_select_set_color;
   selector_class->set_channel           = gimp_color_select_set_channel;
   selector_class->set_config            = gimp_color_select_set_config;
+
+  fish_rgb_to_lch    = babl_fish (babl_format ("R'G'B'A double"),
+                                  babl_format ("CIE LCH(ab) double"));
+  fish_lch_to_rgb    = babl_fish (babl_format ("CIE LCH(ab) double"),
+                                  babl_format ("R'G'B' double"));
+  fish_lch_to_rgb_u8 = babl_fish (babl_format ("CIE LCH(ab) double"),
+                                  babl_format ("R'G'B' u8"));
 }
 
 static void
 gimp_color_select_init (GimpColorSelect *select)
 {
-  GtkWidget *hbox;
-  GtkWidget *frame;
+  GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
+  GtkWidget         *hbox;
+  GtkWidget         *frame;
 
   select->z_color_fill  = COLOR_SELECT_HUE;
   select->xy_color_fill = COLOR_SELECT_SATURATION_VALUE;
@@ -330,13 +387,16 @@ gimp_color_select_init (GimpColorSelect *select)
 
     enum_class = g_type_class_ref (GIMP_TYPE_COLOR_SELECTOR_CHANNEL);
 
-    for (channel = GIMP_COLOR_SELECTOR_HUE;
-         channel < GIMP_COLOR_SELECTOR_ALPHA;
+    for (channel =  GIMP_COLOR_SELECTOR_HUE;
+         channel <= GIMP_COLOR_SELECTOR_LCH_HUE;
          channel++)
       {
         GimpEnumDesc *enum_desc;
         GtkWidget    *button;
 
+        if (channel == GIMP_COLOR_SELECTOR_ALPHA)
+          continue;
+
         enum_desc = gimp_enum_get_desc (enum_class, channel);
 
         button = gtk_radio_button_new_with_mnemonic (group,
@@ -350,7 +410,7 @@ gimp_color_select_init (GimpColorSelect *select)
         g_object_set_data (G_OBJECT (button), "channel",
                            GINT_TO_POINTER (channel));
 
-        if (channel == GIMP_COLOR_SELECTOR_HUE)
+        if (channel == selector->channel)
           gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 
         gimp_help_set_help_data (button, gettext (enum_desc->value_help), NULL);
@@ -431,6 +491,21 @@ gimp_color_select_set_channel (GimpColorSelector        *selector,
       select->xy_color_fill = COLOR_SELECT_RED_GREEN;
       break;
 
+    case COLOR_SELECT_LCH_LIGHTNESS:
+      select->z_color_fill  = COLOR_SELECT_LCH_LIGHTNESS;
+      select->xy_color_fill = COLOR_SELECT_LCH_HUE_CHROMA;
+      break;
+
+    case COLOR_SELECT_LCH_CHROMA:
+      select->z_color_fill  = COLOR_SELECT_LCH_CHROMA;
+      select->xy_color_fill = COLOR_SELECT_LCH_HUE_LIGHTNESS;
+      break;
+
+     case COLOR_SELECT_LCH_HUE:
+      select->z_color_fill  = COLOR_SELECT_LCH_HUE;
+      select->xy_color_fill = COLOR_SELECT_LCH_CHROMA_LIGHTNESS;
+      break;
+
     default:
       break;
     }
@@ -477,8 +552,6 @@ static void
 gimp_color_select_update (GimpColorSelect       *select,
                           ColorSelectUpdateType  update)
 {
-  GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
-
   if (update & UPDATE_POS)
     gimp_color_select_update_pos (select);
 
@@ -487,15 +560,13 @@ gimp_color_select_update (GimpColorSelect       *select,
 
   if (update & UPDATE_XY_COLOR)
     {
-      gimp_color_select_image_fill (select->xy_color, select->xy_color_fill,
-                                    &selector->hsv, &selector->rgb);
+      select->xy_color_needs_render = TRUE;
       gtk_widget_queue_draw (select->xy_color);
     }
 
   if (update & UPDATE_Z_COLOR)
     {
-      gimp_color_select_image_fill (select->z_color, select->z_color_fill,
-                                    &selector->hsv, &selector->rgb);
+      select->xy_color_needs_render = TRUE;
       gtk_widget_queue_draw (select->z_color);
     }
 
@@ -507,6 +578,7 @@ static void
 gimp_color_select_update_values (GimpColorSelect *select)
 {
   GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
+  GimpLCH            lch;
 
   switch (select->z_color_fill)
     {
@@ -542,6 +614,22 @@ gimp_color_select_update_values (GimpColorSelect *select)
       selector->hsv.v = select->pos[2];
       break;
 
+    case COLOR_SELECT_LCH_LIGHTNESS:
+      lch.h = select->pos[0] * 360;
+      lch.c = select->pos[1] * 100;
+      lch.l = select->pos[2] * 100;
+      break;
+    case COLOR_SELECT_LCH_CHROMA:
+      lch.h = select->pos[0] * 360;
+      lch.l = select->pos[1] * 100;
+      lch.c = select->pos[2] * 100;
+      break;
+    case COLOR_SELECT_LCH_HUE:
+      lch.c = select->pos[0] * 100;
+      lch.l = select->pos[1] * 100;
+      lch.h = select->pos[2] * 360;
+      break;
+
     default:
       break;
     }
@@ -560,6 +648,13 @@ gimp_color_select_update_values (GimpColorSelect *select)
       gimp_hsv_to_rgb (&selector->hsv, &selector->rgb);
       break;
 
+    case COLOR_SELECT_LCH_LIGHTNESS:
+    case COLOR_SELECT_LCH_CHROMA:
+    case COLOR_SELECT_LCH_HUE:
+      babl_process (fish_lch_to_rgb, &lch, &selector->rgb, 1);
+      gimp_rgb_to_hsv (&selector->rgb, &selector->hsv);
+      break;
+
     default:
       break;
     }
@@ -569,6 +664,9 @@ static void
 gimp_color_select_update_pos (GimpColorSelect *select)
 {
   GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
+  GimpLCH            lch;
+
+  babl_process (fish_rgb_to_lch, &selector->rgb, &lch, 1);
 
   switch (select->z_color_fill)
     {
@@ -604,6 +702,22 @@ gimp_color_select_update_pos (GimpColorSelect *select)
       select->pos[2] = CLAMP (selector->hsv.v, 0.0, 1.0);
       break;
 
+    case COLOR_SELECT_LCH_LIGHTNESS:
+      select->pos[0] = CLAMP (lch.h / 360, 0.0, 1.0);
+      select->pos[1] = CLAMP (lch.c / 100, 0.0, 1.0);
+      select->pos[2] = CLAMP (lch.l / 100, 0.0, 1.0);
+      break;
+    case COLOR_SELECT_LCH_CHROMA:
+      select->pos[0] = CLAMP (lch.h / 360, 0.0, 1.0);
+      select->pos[1] = CLAMP (lch.l / 100, 0.0, 1.0);
+      select->pos[2] = CLAMP (lch.c / 100, 0.0, 1.0);
+      break;
+    case COLOR_SELECT_LCH_HUE:
+      select->pos[0] = CLAMP (lch.c / 100, 0.0, 1.0);
+      select->pos[1] = CLAMP (lch.l / 100, 0.0, 1.0);
+      select->pos[2] = CLAMP (lch.h / 360, 0.0, 1.0);
+      break;
+
     default:
       break;
     }
@@ -622,6 +736,7 @@ gimp_color_select_drop_color (GtkWidget     *widget,
   select->rgb = *color;
 
   gimp_color_select_update_hsv_values (select);
+  gimp_color_select_update_lch_values (select);
 
   gimp_color_select_update (select,
                             UPDATE_POS | UPDATE_XY_COLOR | UPDATE_Z_COLOR |
@@ -646,6 +761,17 @@ gimp_color_select_xy_expose (GtkWidget       *widget,
   cairo_t       *cr;
   gint           x, y;
 
+  if (select->xy_color_needs_render)
+    {
+      GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
+
+      gimp_color_select_render (select->xy_color,
+                                select->xy_color_fill,
+                                &selector->hsv,
+                                &selector->rgb);
+      select->xy_color_needs_render = FALSE;
+    }
+
   gtk_widget_get_allocation (select->xy_color, &allocation);
 
   cr = gdk_cairo_create (gtk_widget_get_window (widget));
@@ -768,6 +894,17 @@ gimp_color_select_z_expose (GtkWidget       *widget,
   cairo_t       *cr;
   gint           y;
 
+  if (select->z_color_needs_render)
+    {
+      GimpColorSelector *selector = GIMP_COLOR_SELECTOR (select);
+
+       gimp_color_select_render (select->z_color,
+                                 select->z_color_fill,
+                                 &selector->hsv,
+                                 &selector->rgb);
+      select->z_color_needs_render = FALSE;
+    }
+
   gtk_widget_get_allocation (widget, &allocation);
 
   cr = gdk_cairo_create (gtk_widget_get_window (widget));
@@ -864,10 +1001,10 @@ gimp_color_select_z_events (GtkWidget       *widget,
 }
 
 static void
-gimp_color_select_image_fill (GtkWidget           *preview,
-                              ColorSelectFillType  fill_type,
-                              const GimpHSV       *hsv,
-                              const GimpRGB       *rgb)
+gimp_color_select_render (GtkWidget           *preview,
+                          ColorSelectFillType  fill_type,
+                          const GimpHSV       *hsv,
+                          const GimpRGB       *rgb)
 {
   GtkAllocation   allocation;
   ColorSelectFill csf;
@@ -881,6 +1018,8 @@ gimp_color_select_image_fill (GtkWidget           *preview,
   csf.rgb    = *rgb;
   csf.update = update_procs[fill_type];
 
+  babl_process (fish_rgb_to_lch, rgb, &csf.lch, 1);
+
   for (csf.y = 0; csf.y < csf.height; csf.y++)
     {
       if (csf.update)
@@ -894,7 +1033,7 @@ gimp_color_select_image_fill (GtkWidget           *preview,
 }
 
 static void
-color_select_update_red (ColorSelectFill *csf)
+color_select_render_red (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, r;
@@ -911,7 +1050,7 @@ color_select_update_red (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_green (ColorSelectFill *csf)
+color_select_render_green (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, g;
@@ -928,7 +1067,7 @@ color_select_update_green (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_blue (ColorSelectFill *csf)
+color_select_render_blue (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, b;
@@ -945,7 +1084,7 @@ color_select_update_blue (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_hue (ColorSelectFill *csf)
+color_select_render_hue (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gfloat  h, f;
@@ -1003,7 +1142,7 @@ color_select_update_hue (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_saturation (ColorSelectFill *csf)
+color_select_render_saturation (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    s;
@@ -1023,7 +1162,7 @@ color_select_update_saturation (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_value (ColorSelectFill *csf)
+color_select_render_value (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    v;
@@ -1043,7 +1182,64 @@ color_select_update_value (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_red_green (ColorSelectFill *csf)
+color_select_render_lch_lightness (ColorSelectFill *csf)
+{
+  guchar  *p   = csf->buffer;
+  GimpLCH  lch = { 0.0, 0.0, 0.0, 1.0 };
+  guchar   rgb[3];
+  gint     i;
+
+  lch.l = (csf->height - 1 - csf->y) * 100.0 / csf->height;
+  babl_process (fish_lch_to_rgb_u8, &lch, &rgb, 1);
+
+  for (i = 0; i < csf->width; i++)
+    {
+      *p++ = rgb[0];
+      *p++ = rgb[1];
+      *p++ = rgb[2];
+    }
+}
+
+static void
+color_select_render_lch_chroma (ColorSelectFill *csf)
+{
+  guchar  *p   = csf->buffer;
+  GimpLCH  lch = { 80.0, 0.0, 0.0, 1.0 };
+  guchar   rgb[3];
+  gint     i;
+
+  lch.c = (csf->height - 1 - csf->y) * 100.0 / csf->height ;
+  babl_process (fish_lch_to_rgb_u8, &lch, &rgb, 1);
+
+  for (i = 0; i < csf->width; i++)
+    {
+      *p++ = rgb[0];
+      *p++ = rgb[1];
+      *p++ = rgb[2];
+    }
+}
+
+static void
+color_select_render_lch_hue (ColorSelectFill *csf)
+{
+  guchar  *p   = csf->buffer;
+  GimpLCH  lch = { 80.0, 200.0, 0.0, 1.0 };
+  guchar   rgb[3];
+  gint     i;
+
+  lch.h = (csf->height - 1 - csf->y) * 360.0 / csf->height;
+  babl_process (fish_lch_to_rgb_u8, &lch, &rgb, 1);
+
+  for (i = 0; i < csf->width; i++)
+    {
+      *p++ = rgb[0];
+      *p++ = rgb[1];
+      *p++ = rgb[2];
+    }
+}
+
+static void
+color_select_render_red_green (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, g, b;
@@ -1068,7 +1264,7 @@ color_select_update_red_green (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_red_blue (ColorSelectFill *csf)
+color_select_render_red_blue (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, g, b;
@@ -1093,7 +1289,7 @@ color_select_update_red_blue (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_green_blue (ColorSelectFill *csf)
+color_select_render_green_blue (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gint    i, r, b;
@@ -1118,7 +1314,7 @@ color_select_update_green_blue (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_hue_saturation (ColorSelectFill *csf)
+color_select_render_hue_saturation (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gfloat  h, dh, s, v;
@@ -1177,7 +1373,7 @@ color_select_update_hue_saturation (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_hue_value (ColorSelectFill *csf)
+color_select_render_hue_value (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gfloat  h, dh, s, v;
@@ -1236,7 +1432,7 @@ color_select_update_hue_value (ColorSelectFill *csf)
 }
 
 static void
-color_select_update_saturation_value (ColorSelectFill *csf)
+color_select_render_saturation_value (ColorSelectFill *csf)
 {
   guchar *p = csf->buffer;
   gfloat  h, s, ds, v;
@@ -1320,3 +1516,132 @@ color_select_update_saturation_value (ColorSelectFill *csf)
       break;
     }
 }
+
+static void
+color_select_render_lch_chroma_lightness (ColorSelectFill *csf)
+{
+  guchar  *p = csf->buffer;
+  GimpLCH  lch;
+  gint     i;
+
+  lch.l = (csf->height - 1 - csf->y) * 100.0 / csf->height;
+  lch.h = csf->lch.h;
+
+  for (i = 0; i < csf->width; i++)
+    {
+      GimpRGB rgb;
+
+      lch.c = i * 100.0 / csf->width;
+
+      babl_process (fish_lch_to_rgb, &lch, &rgb, 1);
+
+      if (rgb.r < 0.0 ||
+          rgb.g < 0.0 ||
+          rgb.b < 0.0)
+        {
+          p[0] = 255;
+          p[1] = 255;
+          p[2] = 255;
+        }
+      else if (rgb.r > 1.0 ||
+               rgb.g > 1.0 ||
+               rgb.b > 1.0)
+        {
+          p[0] = 0;
+          p[1] = 0;
+          p[2] = 0;
+        }
+      else
+        {
+          gimp_rgb_get_uchar (&rgb, p, p + 1, p + 2);
+        }
+
+      p += 3;
+    }
+}
+
+static void
+color_select_render_lch_hue_lightness (ColorSelectFill *csf)
+{
+  guchar  *p = csf->buffer;
+  GimpLCH  lch;
+  gint     i;
+
+  lch.l = (csf->height - 1 - csf->y) * 100.0 / csf->height;
+  lch.c = csf->lch.c;
+
+  for (i = 0; i < csf->width; i++)
+    {
+      GimpRGB rgb;
+
+      lch.h = i * 360.0 / csf->width;
+
+      babl_process (fish_lch_to_rgb, &lch, &rgb, 1);
+
+      if (rgb.r < 0.0 ||
+          rgb.g < 0.0 ||
+          rgb.b < 0.0)
+        {
+          p[0] = 255;
+          p[1] = 255;
+          p[2] = 255;
+        }
+      else if (rgb.r > 1.0 ||
+               rgb.g > 1.0 ||
+               rgb.b > 1.0)
+        {
+          p[0] = 0;
+          p[1] = 0;
+          p[2] = 0;
+        }
+      else
+        {
+          gimp_rgb_get_uchar (&rgb, p, p + 1, p + 2);
+        }
+
+      p += 3;
+    }
+}
+
+static void
+color_select_render_lch_hue_chroma (ColorSelectFill *csf)
+{
+  guchar  *p = csf->buffer;
+  GimpLCH  lch;
+  gint     i;
+
+  lch.l = csf->lch.l;
+  lch.c = (csf->height - 1 - csf->y) * 100.0 / csf->height;
+
+  for (i = 0; i < csf->width; i++)
+    {
+      GimpRGB rgb;
+
+      lch.h = i * 360.0 / csf->width;
+
+       babl_process (fish_lch_to_rgb, &lch, &rgb, 1);
+
+      if (rgb.r < 0.0 ||
+          rgb.g < 0.0 ||
+          rgb.b < 0.0)
+        {
+          p[0] = 255;
+          p[1] = 255;
+          p[2] = 255;
+        }
+      else if (rgb.r > 1.0 ||
+               rgb.g > 1.0 ||
+               rgb.b > 1.0)
+        {
+          p[0] = 0;
+          p[1] = 0;
+          p[2] = 0;
+        }
+      else
+        {
+          gimp_rgb_get_uchar (&rgb, p, p + 1, p + 2);
+        }
+
+      p += 3;
+    }
+}
diff --git a/libgimpwidgets/gimpwidgetsenums.c b/libgimpwidgets/gimpwidgetsenums.c
index fa6bfff5f3..829c284ef5 100644
--- a/libgimpwidgets/gimpwidgetsenums.c
+++ b/libgimpwidgets/gimpwidgetsenums.c
@@ -118,18 +118,24 @@ gimp_color_selector_channel_get_type (void)
     { GIMP_COLOR_SELECTOR_GREEN, "GIMP_COLOR_SELECTOR_GREEN", "green" },
     { GIMP_COLOR_SELECTOR_BLUE, "GIMP_COLOR_SELECTOR_BLUE", "blue" },
     { GIMP_COLOR_SELECTOR_ALPHA, "GIMP_COLOR_SELECTOR_ALPHA", "alpha" },
+    { GIMP_COLOR_SELECTOR_LCH_LIGHTNESS, "GIMP_COLOR_SELECTOR_LCH_LIGHTNESS", "lch-lightness" },
+    { GIMP_COLOR_SELECTOR_LCH_CHROMA, "GIMP_COLOR_SELECTOR_LCH_CHROMA", "lch-chroma" },
+    { GIMP_COLOR_SELECTOR_LCH_HUE, "GIMP_COLOR_SELECTOR_LCH_HUE", "lch-hue" },
     { 0, NULL, NULL }
   };
 
   static const GimpEnumDesc descs[] =
   {
-    { GIMP_COLOR_SELECTOR_HUE, NC_("color-selector-channel", "_H"), N_("Hue") },
-    { GIMP_COLOR_SELECTOR_SATURATION, NC_("color-selector-channel", "_S"), N_("Saturation") },
-    { GIMP_COLOR_SELECTOR_VALUE, NC_("color-selector-channel", "_V"), N_("Value") },
+    { GIMP_COLOR_SELECTOR_HUE, NC_("color-selector-channel", "_H"), N_("HSV Hue") },
+    { GIMP_COLOR_SELECTOR_SATURATION, NC_("color-selector-channel", "_S"), N_("HSV Saturation") },
+    { GIMP_COLOR_SELECTOR_VALUE, NC_("color-selector-channel", "_V"), N_("HSV Value") },
     { GIMP_COLOR_SELECTOR_RED, NC_("color-selector-channel", "_R"), N_("Red") },
     { GIMP_COLOR_SELECTOR_GREEN, NC_("color-selector-channel", "_G"), N_("Green") },
     { GIMP_COLOR_SELECTOR_BLUE, NC_("color-selector-channel", "_B"), N_("Blue") },
     { GIMP_COLOR_SELECTOR_ALPHA, NC_("color-selector-channel", "_A"), N_("Alpha") },
+    { GIMP_COLOR_SELECTOR_LCH_LIGHTNESS, NC_("color-selector-channel", "_L"), N_("LCH Lightness") },
+    { GIMP_COLOR_SELECTOR_LCH_CHROMA, NC_("color-selector-channel", "_C"), N_("LCH Chroma") },
+    { GIMP_COLOR_SELECTOR_LCH_HUE, NC_("color-selector-channel", "_H"), N_("LCH Hue") },
     { 0, NULL, NULL }
   };
 
diff --git a/libgimpwidgets/gimpwidgetsenums.h b/libgimpwidgets/gimpwidgetsenums.h
index a93c24d503..0d8ca48c7c 100644
--- a/libgimpwidgets/gimpwidgetsenums.h
+++ b/libgimpwidgets/gimpwidgetsenums.h
@@ -89,13 +89,16 @@ typedef enum
 
 /**
  * GimpColorSelectorChannel:
- * @GIMP_COLOR_SELECTOR_HUE:        the hue channel
- * @GIMP_COLOR_SELECTOR_SATURATION: the saturation channel
- * @GIMP_COLOR_SELECTOR_VALUE:      the value channel
- * @GIMP_COLOR_SELECTOR_RED:        the red channel
- * @GIMP_COLOR_SELECTOR_GREEN:      the green channel
- * @GIMP_COLOR_SELECTOR_BLUE:       the blue channel
- * @GIMP_COLOR_SELECTOR_ALPHA:      the alpha channel
+ * @GIMP_COLOR_SELECTOR_HUE:            the hue channel
+ * @GIMP_COLOR_SELECTOR_SATURATION:     the saturation channel
+ * @GIMP_COLOR_SELECTOR_VALUE:          the value channel
+ * @GIMP_COLOR_SELECTOR_RED:            the red channel
+ * @GIMP_COLOR_SELECTOR_GREEN:          the green channel
+ * @GIMP_COLOR_SELECTOR_BLUE:           the blue channel
+ * @GIMP_COLOR_SELECTOR_ALPHA:          the alpha channel
+ * @GIMP_COLOR_SELECTOR_LCH_LIGHTNESS:  the lightness channel
+ * @GIMP_COLOR_SELECTOR_LCH_CHOMA:      the chroma channel
+ * @GIMP_COLOR_SELECTOR_LCH_HUE:        the hue channel
  *
  * An enum to specify the types of color channels edited in
  * #GimpColorSelector widgets.
@@ -106,13 +109,16 @@ GType gimp_color_selector_channel_get_type (void) G_GNUC_CONST;
 
 typedef enum
 {
-  GIMP_COLOR_SELECTOR_HUE,        /*< desc="_H", help="Hue"        >*/
-  GIMP_COLOR_SELECTOR_SATURATION, /*< desc="_S", help="Saturation" >*/
-  GIMP_COLOR_SELECTOR_VALUE,      /*< desc="_V", help="Value"      >*/
-  GIMP_COLOR_SELECTOR_RED,        /*< desc="_R", help="Red"        >*/
-  GIMP_COLOR_SELECTOR_GREEN,      /*< desc="_G", help="Green"      >*/
-  GIMP_COLOR_SELECTOR_BLUE,       /*< desc="_B", help="Blue"       >*/
-  GIMP_COLOR_SELECTOR_ALPHA       /*< desc="_A", help="Alpha"      >*/
+  GIMP_COLOR_SELECTOR_HUE,           /*< desc="_H", help="HSV Hue"        >*/
+  GIMP_COLOR_SELECTOR_SATURATION,    /*< desc="_S", help="HSV Saturation" >*/
+  GIMP_COLOR_SELECTOR_VALUE,         /*< desc="_V", help="HSV Value"      >*/
+  GIMP_COLOR_SELECTOR_RED,           /*< desc="_R", help="Red"            >*/
+  GIMP_COLOR_SELECTOR_GREEN,         /*< desc="_G", help="Green"          >*/
+  GIMP_COLOR_SELECTOR_BLUE,          /*< desc="_B", help="Blue"           >*/
+  GIMP_COLOR_SELECTOR_ALPHA,         /*< desc="_A", help="Alpha"          >*/
+  GIMP_COLOR_SELECTOR_LCH_LIGHTNESS, /*< desc="_L", help="LCH Lightness"  >*/
+  GIMP_COLOR_SELECTOR_LCH_CHROMA,    /*< desc="_C", help="LCH Chroma"     >*/
+  GIMP_COLOR_SELECTOR_LCH_HUE        /*< desc="_H", help="LCH Hue"        >*/
 } GimpColorSelectorChannel;
 
 
