OkHsv, OkHsl (rebased)

src/ColorPicker.AvaloniaUI/DualPickerControlBase.cs

@@ -10,11 +10,11 @@ public class DualPickerControlBase : PickerControlBase, ISecondColorStorage, IHi
 {
     public static readonly StyledProperty<ColorState> SecondColorStateProperty =
         AvaloniaProperty.Register<DualPickerControlBase, ColorState>(
-            nameof(SecondColorState), new ColorState(1, 1, 1, 1, 0, 0, 1, 0, 0, 1));
+            nameof(SecondColorState), new ColorState(1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1));
 
     public static readonly StyledProperty<ColorState> HintColorStateProperty =
         AvaloniaProperty.Register<DualPickerControlBase, ColorState>(
-            nameof(HintColorState), new ColorState(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+            nameof(HintColorState), new ColorState(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
 
     public static readonly StyledProperty<Color> SecondaryColorProperty =
         AvaloniaProperty.Register<DualPickerControlBase, Color>(

src/ColorPicker.AvaloniaUI/PickerControlBase.cs

@@ -11,7 +11,7 @@ public class PickerControlBase : TemplatedControl, IColorStateStorage
 {
     public static readonly StyledProperty<ColorState> ColorStateProperty =
         AvaloniaProperty.Register<PickerControlBase, ColorState>(
-            nameof(ColorState), new ColorState(0, 0, 0, 1, 0, 0, 0, 0, 0, 0));
+            nameof(ColorState), new ColorState(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
 
     public static readonly StyledProperty<Color> SelectedColorProperty =
         AvaloniaProperty.Register<PickerControlBase, Color>(

src/ColorPicker.AvaloniaUI/SquareSlider.cs

@@ -177,6 +177,10 @@ private void RecalculateGradient()
     private static void OnColorSpaceChanged(AvaloniaPropertyChangedEventArgs<PickerType> args)
     {
         var sender = (SquareSlider)args.Sender;
+        if (args.NewValue.Value == PickerType.OKHSV)
+            sender.colorSpaceConversionMethod = static (h, s, v) => Models.ColorSpaces.RgbHelper.OkHsvToRgb(h, s, v);
+        if (args.NewValue.Value == PickerType.OKHSL)
+            sender.colorSpaceConversionMethod = static (h, s, l) => Models.ColorSpaces.RgbHelper.OkHslToRgb(h, s, l);
         if (args.NewValue.Value == PickerType.HSV)
             sender.colorSpaceConversionMethod = ColorSpaceHelper.HsvToRgb;
         else

src/ColorPicker.Models/ColorSliders/ColorSliderGradientPoint.cs

@@ -0,0 +1,32 @@
+using System;
+using ColorPicker.Models.Colors;
+
+namespace ColorPicker.Models.ColorSliders
+{
+    public struct ColorSliderGradientPoint
+    {
+        public double R;
+        public double G;
+        public double B;
+        public double A;
+        public double Position;
+
+        public ColorSliderGradientPoint(double r, double g, double b, double position)
+        {
+            R = r;
+            G = g;
+            B = b;
+            A = 1.0;
+            Position = position;
+        }
+
+        public ColorSliderGradientPoint(Rgb rgb, double position)
+        {
+            R = rgb.R;
+            G = rgb.G;
+            B = rgb.B;
+            A = 1.0;
+            Position = position;
+        }
+    }
+}

src/ColorPicker.Models/ColorSliders/ColorSliderType.cs

@@ -0,0 +1,26 @@
+namespace ColorPicker.Models.ColorSliders
+{
+    public enum ColorSliderType
+    {
+        RgbRed,
+        RgbGreen,
+        RgbBlue,
+        Alpha,
+
+        HsvHslHue,
+
+        HsvSaturation,
+        HsvValue,
+
+        HslSaturation,
+        HslLightness,
+
+        OkHsvHue,
+        OkHsvSaturation,
+        OkHsvValue,
+
+        OkHslHue,
+        OkHslSaturation,
+        OkHslLightness,
+    }
+}

src/ColorPicker.Models/ColorSliders/ColorSliderTypeFactory.cs

@@ -0,0 +1,47 @@
+using System;
+using ColorPicker.Models.ColorSliders.Types;
+
+namespace ColorPicker.Models.ColorSliders
+{
+    public static class ColorSliderTypeFactory
+    {
+        public static IColorSliderType Get(ColorSliderType type)
+        {
+            switch (type)
+            {
+                case ColorSliderType.RgbRed:
+                    return new RgbRedColorSliderType();
+                case ColorSliderType.RgbGreen:
+                    return new RgbGreenColorSliderType();
+                case ColorSliderType.RgbBlue:
+                    return new RgbBlueColorSliderType();
+                case ColorSliderType.Alpha:
+                    return new AlphaColorSliderType();
+                case ColorSliderType.HsvHslHue:
+                    return new HsvHslHueColorSliderType();
+                case ColorSliderType.HsvSaturation:
+                    return new HsvSaturationColorSliderType();
+                case ColorSliderType.HsvValue:
+                    return new HsvValueColorSliderType();
+                case ColorSliderType.HslSaturation:
+                    return new HslSaturationColorSliderType();
+                case ColorSliderType.HslLightness:
+                    return new HslLightnessColorSliderType();
+                case ColorSliderType.OkHsvHue:
+                    return new OkHsvHueColorSliderType();
+                case ColorSliderType.OkHsvSaturation:
+                    return new OkHsvSaturationColorSliderType();
+                case ColorSliderType.OkHsvValue:
+                    return new OkHsvValueColorSliderType();
+                case ColorSliderType.OkHslHue:
+                    return new OkHslHueColorSliderType();
+                case ColorSliderType.OkHslSaturation:
+                    return new OkHslSaturationColorSliderType();
+                case ColorSliderType.OkHslLightness:
+                    return new OkHslLightnessColorSliderType();
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type));
+            }
+        }
+    }
+}

src/ColorPicker.Models/ColorSliders/IColorSliderType.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+
+namespace ColorPicker.Models.ColorSliders
+{
+    public interface IColorSliderType
+    {
+        List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState currentColorState, bool enabled);
+        bool RefreshGradient { get; }
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/AlphaColorSliderType.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class AlphaColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0),
+                GetPointAt(1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(double value)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(state.RGB_R, state.RGB_G, state.RGB_B, value) { A = value };
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.RgbToGrayTuple(state.RGB_R, state.RGB_G, state.RGB_B), value) { A = value };
+            }
+        }
+
+        public bool RefreshGradient => true;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/HslLightnessColorSliderType.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class HslLightnessColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0),
+                GetPointAt(0.25),
+                GetPointAt(0.5),
+                GetPointAt(0.75),
+                GetPointAt(1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(double value)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(RgbHelper.HslToRgb(state.HSL_H, state.HSL_S, value), value);
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.HslToGray(state.HSL_H, state.HSL_S, value), value);
+            }
+        }
+
+        public bool RefreshGradient => true;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/HslSaturationColorSliderType.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class HslSaturationColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0),
+                GetPointAt(1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(double value)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(RgbHelper.HslToRgb(state.HSL_H, value, state.HSL_L), value);
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.HslToGray(state.HSL_H, 0, state.HSL_L), value);
+            }
+        }
+
+        public bool RefreshGradient => true;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/HsvHslHueColorSliderType.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class HsvHslHueColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAtHue(0, 0),
+                GetPointAtHue(60, 1 / 6.0),
+                GetPointAtHue(120, 2 / 6.0),
+                GetPointAtHue(180, 0.5),
+                GetPointAtHue(240, 4 / 6.0),
+                GetPointAtHue(300, 5 / 6.0),
+                GetPointAtHue(0, 1)
+            };
+
+            ColorSliderGradientPoint GetPointAtHue(int value, double position)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(RgbHelper.HsvToRgb(value, 1.0, 1.0), position);
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.HsvToGray(value, 1.0, 1.0), position);
+            }
+        }
+
+        public bool RefreshGradient => false;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/HsvSaturationColorSliderType.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class HsvSaturationColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0),
+                GetPointAt(1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(double value)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(RgbHelper.HsvToRgb(state.HSV_H, value, state.HSV_V), value);
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.HsvToGray(state.HSV_H, value, state.HSV_V), value);
+            }
+        }
+
+        public bool RefreshGradient => true;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/HsvValueColorSliderType.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class HsvValueColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0),
+                GetPointAt(1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(double value)
+            {
+                if (enabled)
+                    return new ColorSliderGradientPoint(RgbHelper.HsvToRgb(state.HSV_H, state.HSV_S, value), value);
+                else
+                    return new ColorSliderGradientPoint((Colors.Rgb)ColorSpaceHelper.HsvToGray(state.HSV_H, state.HSV_S, value), value);
+            }
+        }
+
+        public bool RefreshGradient => true;
+    }
+}

src/ColorPicker.Models/ColorSliders/Types/OkHslHueColorSliderType.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using ColorPicker.Models.ColorSpaces;
+
+namespace ColorPicker.Models.ColorSliders.Types
+{
+    internal class OkHslHueColorSliderType : IColorSliderType
+    {
+        public List<ColorSliderGradientPoint> CalculateRgbGradient(ColorState state, bool enabled)
+        {
+            return new List<ColorSliderGradientPoint>()
+            {
+                GetPointAt(0, 0),
+                GetPointAt(22, 22 / 360.0),
+                GetPointAt(51, 51 / 360.00),
+                GetPointAt(139, 139 / 360.0),
+                GetPointAt(199, 199 / 360.0),
+                GetPointAt(245, 245 / 360.0),
+                GetPointAt(280, 280 / 360.0),
+                GetPointAt(0, 1)
+            };
+
+            ColorSliderGradientPoint GetPointAt(int value, double position)
+            {
+                var rgb = RgbHelper.OkHslToRgb(value, 1.0, 0.62);
+
+                if (!enabled)
+                    rgb = (Colors.Rgb)ColorSpaceHelper.RgbToGrayTuple(rgb.R, rgb.G, rgb.B);
+
+                return new ColorSliderGradientPoint(rgb, position);
+            }
+        }
+
+        public bool RefreshGradient => false;
+    }
+}