Updater/PackageUpdater/Microsoft.Windows.Forms/Util/RenderEngine.1.HLSColor.cs

using System;
using System.Drawing;

namespace Microsoft.Windows.Forms
{
    public static partial class RenderEngine
    {
        /// <summary>
        /// 色调,亮度,饱和度颜色
        /// </summary>
        private struct HLSColor
        {
            private const int ShadowAdj = -333;
            private const int HilightAdj = 500;
            private const int WatermarkAdj = -50;
            private const int Range = 240;
            private const int HLSMax = Range;
            private const int RGBMax = 255;
            private const int Undefined = HLSMax * 2 / 3;

            private int hue;
            private int saturation;
            private int luminosity;
            private bool isSystemColors_Control;

            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="color">RGBA颜色</param>
            public HLSColor(Color color)
            {
                isSystemColors_Control = (color.ToKnownColor() == SystemColors.Control.ToKnownColor());
                int r = color.R;
                int g = color.G;
                int b = color.B;
                int max, min;        /* max and min RGB values */
                int sum, dif;
                int Rdelta, Gdelta, Bdelta;  /* intermediate value: % of spread from max */

                /* calculate lightness */
                max = Math.Max(Math.Max(r, g), b);
                min = Math.Min(Math.Min(r, g), b);
                sum = max + min;

                luminosity = (((sum * HLSMax) + RGBMax) / (2 * RGBMax));

                dif = max - min;
                if (dif == 0)
                {       /* r=g=b --> achromatic case */
                    saturation = 0;                         /* saturation */
                    hue = Undefined;                 /* hue */
                }
                else
                {                           /* chromatic case */
                    /* saturation */
                    if (luminosity <= (HLSMax / 2))
                        saturation = (int)(((dif * (int)HLSMax) + (sum / 2)) / sum);
                    else
                        saturation = (int)((int)((dif * (int)HLSMax) + (int)((2 * RGBMax - sum) / 2))
                                            / (2 * RGBMax - sum));
                    /* hue */
                    Rdelta = (int)((((max - r) * (int)(HLSMax / 6)) + (dif / 2)) / dif);
                    Gdelta = (int)((((max - g) * (int)(HLSMax / 6)) + (dif / 2)) / dif);
                    Bdelta = (int)((((max - b) * (int)(HLSMax / 6)) + (dif / 2)) / dif);

                    if ((int)r == max)
                        hue = Bdelta - Gdelta;
                    else if ((int)g == max)
                        hue = (HLSMax / 3) + Rdelta - Bdelta;
                    else /* B == cMax */
                        hue = ((2 * HLSMax) / 3) + Gdelta - Rdelta;

                    if (hue < 0)
                        hue += HLSMax;
                    if (hue > HLSMax)
                        hue -= HLSMax;
                }
            }

            /// <summary>
            /// 色调
            /// </summary>
            public int Hue
            {
                get
                {
                    return hue;
                }
            }

            /// <summary>
            /// 亮度
            /// </summary>
            public int Luminosity
            {
                get
                {
                    return luminosity;
                }
            }

            /// <summary>
            /// 饱和度
            /// </summary>
            public int Saturation
            {
                get
                {
                    return saturation;
                }
            }

            /// <summary>
            /// 获取减小指定亮度后的颜色
            /// </summary>
            /// <param name="percDarker">要减小的亮度</param>
            /// <returns>新的颜色</returns>
            public Color Darker(float percDarker)
            {
                if (isSystemColors_Control)
                {
                    // With the usual color scheme, ControlDark/DarkDark is not exactly
                    // what we would otherwise calculate
                    if (percDarker == 0.0f)
                    {
                        return SystemColors.ControlDark;
                    }
                    else if (percDarker == 1.0f)
                    {
                        return SystemColors.ControlDarkDark;
                    }
                    else
                    {
                        Color dark = SystemColors.ControlDark;
                        Color darkDark = SystemColors.ControlDarkDark;

                        int dr = dark.R - darkDark.R;
                        int dg = dark.G - darkDark.G;
                        int db = dark.B - darkDark.B;

                        return Color.FromArgb((byte)(dark.R - (byte)(dr * percDarker)),
                                              (byte)(dark.G - (byte)(dg * percDarker)),
                                              (byte)(dark.B - (byte)(db * percDarker)));
                    }
                }
                else
                {
                    int oneLum = 0;
                    int zeroLum = NewLuma(ShadowAdj, true);
                    return ColorFromHLS(hue, zeroLum - (int)((zeroLum - oneLum) * percDarker), saturation);
                }
            }

            /// <summary>
            /// 是否相等
            /// </summary>
            /// <param name="o">要比较的对象</param>
            /// <returns>相等返回true,否则返回false</returns>
            public override bool Equals(object o)
            {
                if (!(o is HLSColor))
                {
                    return false;
                }

                HLSColor c = (HLSColor)o;
                return hue == c.hue &&
                       saturation == c.saturation &&
                       luminosity == c.luminosity &&
                       isSystemColors_Control == c.isSystemColors_Control;
            }

            /// <summary>
            /// 是否相等
            /// </summary>
            /// <param name="a">颜色a</param>
            /// <param name="b">颜色b</param>
            /// <returns>相等返回true,否则返回false</returns>
            public static bool operator ==(HLSColor a, HLSColor b)
            {
                return a.Equals(b);
            }

            /// <summary>
            /// 是否不等
            /// </summary>
            /// <param name="a">颜色a</param>
            /// <param name="b">颜色b</param>
            /// <returns>不等返回true,否则返回false</returns>
            public static bool operator !=(HLSColor a, HLSColor b)
            {
                return !a.Equals(b);
            }

            /// <summary>
            /// 获取哈希码
            /// </summary>
            /// <returns>哈希码</returns>
            public override int GetHashCode()
            {
                return hue << 6 | saturation << 2 | luminosity;
            }

            /// <summary>
            /// 获取增加指定亮度后的颜色
            /// </summary>
            /// <param name="percLighter">要增加的亮度</param>
            /// <returns>新的颜色</returns>
            public Color Lighter(float percLighter)
            {
                if (isSystemColors_Control)
                {
                    // With the usual color scheme, ControlLight/LightLight is not exactly
                    // what we would otherwise calculate
                    if (percLighter == 0.0f)
                    {
                        return SystemColors.ControlLight;
                    }
                    else if (percLighter == 1.0f)
                    {
                        return SystemColors.ControlLightLight;
                    }
                    else
                    {
                        Color light = SystemColors.ControlLight;
                        Color lightLight = SystemColors.ControlLightLight;

                        int dr = light.R - lightLight.R;
                        int dg = light.G - lightLight.G;
                        int db = light.B - lightLight.B;

                        return Color.FromArgb((byte)(light.R - (byte)(dr * percLighter)),
                                              (byte)(light.G - (byte)(dg * percLighter)),
                                              (byte)(light.B - (byte)(db * percLighter)));
                    }
                }
                else
                {
                    int zeroLum = luminosity;
                    int oneLum = NewLuma(HilightAdj, true);
                    return ColorFromHLS(hue, zeroLum + (int)((oneLum - zeroLum) * percLighter), saturation);
                }
            }

            private int NewLuma(int n, bool scale)
            {
                return NewLuma(luminosity, n, scale);
            }

            private int NewLuma(int luminosity, int n, bool scale)
            {
                if (n == 0)
                    return luminosity;

                if (scale)
                {
                    if (n > 0)
                    {
                        return (int)(((int)luminosity * (1000 - n) + (Range + 1L) * n) / 1000);
                    }
                    else
                    {
                        return (int)(((int)luminosity * (n + 1000)) / 1000);
                    }
                }

                int newLum = luminosity;
                newLum += (int)((long)n * Range / 1000);

                if (newLum < 0)
                    newLum = 0;
                if (newLum > HLSMax)
                    newLum = HLSMax;

                return newLum;
            }

            private Color ColorFromHLS(int hue, int luminosity, int saturation)
            {
                byte r, g, b;                      /* RGB component values */
                int magic1, magic2;       /* calculated magic numbers (really!) */

                if (saturation == 0)
                {                /* achromatic case */
                    r = g = b = (byte)((luminosity * RGBMax) / HLSMax);
                    if (hue != Undefined)
                    {
                        /* ERROR */
                    }
                }
                else
                {                         /* chromatic case */
                    /* set up magic numbers */
                    if (luminosity <= (HLSMax / 2))
                        magic2 = (int)((luminosity * ((int)HLSMax + saturation) + (HLSMax / 2)) / HLSMax);
                    else
                        magic2 = luminosity + saturation - (int)(((luminosity * saturation) + (int)(HLSMax / 2)) / HLSMax);
                    magic1 = 2 * luminosity - magic2;

                    /* get RGB, change units from HLSMax to RGBMax */
                    r = (byte)(((HueToRGB(magic1, magic2, (int)(hue + (int)(HLSMax / 3))) * (int)RGBMax + (HLSMax / 2))) / (int)HLSMax);
                    g = (byte)(((HueToRGB(magic1, magic2, hue) * (int)RGBMax + (HLSMax / 2))) / HLSMax);
                    b = (byte)(((HueToRGB(magic1, magic2, (int)(hue - (int)(HLSMax / 3))) * (int)RGBMax + (HLSMax / 2))) / (int)HLSMax);
                }
                return Color.FromArgb(r, g, b);
            }

            private int HueToRGB(int n1, int n2, int hue)
            {
                /* range check: note values passed add/subtract thirds of range */

                /* The following is redundant for WORD (unsigned int) */
                if (hue < 0)
                    hue += HLSMax;

                if (hue > HLSMax)
                    hue -= HLSMax;

                /* return r,g, or b value from this tridrant */
                if (hue < (HLSMax / 6))
                    return (n1 + (((n2 - n1) * hue + (HLSMax / 12)) / (HLSMax / 6)));
                if (hue < (HLSMax / 2))
                    return (n2);
                if (hue < ((HLSMax * 2) / 3))
                    return (n1 + (((n2 - n1) * (((HLSMax * 2) / 3) - hue) + (HLSMax / 12)) / (HLSMax / 6)));
                else
                    return (n1);

            }
        }
    }
}