using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text.RegularExpressions;

namespace Mesnac.Controls.ChemicalWeighing.HslCurve
{
    /// <summary>
    /// 整个组件的代码辅助工具，提供了一个基础的类库方法
    /// </summary>
    // Token: 0x02000034 RID: 52
    public class HslHelper
    {
        // Token: 0x060004DF RID: 1247 RVA: 0x00032DB4 File Offset: 0x00030FB4
        static HslHelper()
        {
            HslHelper.StringFormatCenter = new StringFormat();
            HslHelper.StringFormatCenter.Alignment = StringAlignment.Center;
            HslHelper.StringFormatCenter.LineAlignment = StringAlignment.Center;
            HslHelper.StringFormatLeft = new StringFormat();
            HslHelper.StringFormatLeft.LineAlignment = StringAlignment.Center;
            HslHelper.StringFormatLeft.Alignment = StringAlignment.Near;
            HslHelper.StringFormatRight = new StringFormat();
            HslHelper.StringFormatRight.LineAlignment = StringAlignment.Center;
            HslHelper.StringFormatRight.Alignment = StringAlignment.Far;
            HslHelper.StringFormatTopCenter = new StringFormat();
            HslHelper.StringFormatTopCenter.Alignment = StringAlignment.Center;
            HslHelper.StringFormatTopCenter.LineAlignment = StringAlignment.Near;
        }

        /// <summary>
        /// 返回中间范围值数据，如果大于最大值，则返回最大值，如果小于最小值，则返回最小值
        /// </summary>
        /// <param name="min">最小值</param>
        /// <param name="value">实际值</param>
        /// <param name="max">最大值</param>
        /// <returns>中间值信息</returns>
        // Token: 0x060004E0 RID: 1248 RVA: 0x00032E5C File Offset: 0x0003105C
        public static int Middle(int min, int value, int max)
        {
            bool flag = value > max;
            int result;
            if (flag)
            {
                result = max;
            }
            else
            {
                bool flag2 = value < min;
                if (flag2)
                {
                    result = min;
                }
                else
                {
                    result = value;
                }
            }
            return result;
        }

        /// <summary>
        /// 从一个矩形的图形中获取菱形的坐标数组
        /// </summary>
        /// <param name="rect">矩形</param>
        /// <returns>数组结果</returns>
        // Token: 0x060004E1 RID: 1249 RVA: 0x00032E88 File Offset: 0x00031088
        public static Point[] GetRhombusFromRectangle(Rectangle rect)
        {
            return new Point[]
            {
                new Point(rect.X, rect.Y + rect.Height / 2),
                new Point(rect.X + rect.Width / 2, rect.Y + rect.Height - 1),
                new Point(rect.X + rect.Width - 1, rect.Y + rect.Height / 2),
                new Point(rect.X + rect.Width / 2, rect.Y),
                new Point(rect.X, rect.Y + rect.Height / 2)
            };
        }

        /// <summary>
        /// 计算绘图时的相对偏移值
        /// </summary>
        /// <param name="max">0-100分的最大值，就是指准备绘制的最大值</param>
        /// <param name="min">0-100分的最小值，就是指准备绘制的最小值</param>
        /// <param name="height">实际绘图区域的高度</param>
        /// <param name="value">需要绘制数据的当前值</param>
        /// <returns>相对于0的位置，还需要增加上面的偏值</returns>
        // Token: 0x060004E2 RID: 1250 RVA: 0x00032F68 File Offset: 0x00031168
        public static float ComputePaintLocationY(int max, int min, int height, int value)
        {
            bool flag = (float)(max - min) == 0f;
            float result;
            if (flag)
            {
                result = (float)height;
            }
            else
            {
                result = (float)height - (float)(value - min) * 1f / (float)(max - min) * (float)height;
            }
            return result;
        }

        /// <summary>
        /// 计算绘图Y轴时的相对偏移值
        /// </summary>
        /// <param name="max">0-100分的最大值，就是指准备绘制的最大值</param>
        /// <param name="min">0-100分的最小值，就是指准备绘制的最小值</param>
        /// <param name="height">实际绘图区域的高度</param>
        /// <param name="value">需要绘制数据的当前值</param>
        /// <returns>相对于0的位置，还需要增加上面的偏值</returns>
        // Token: 0x060004E3 RID: 1251 RVA: 0x00032FA8 File Offset: 0x000311A8
        public static float ComputePaintLocationY(float max, float min, float height, float value)
        {
            bool flag = max - min == 0f;
            float result;
            if (flag)
            {
                result = height;
            }
            else
            {
                float num = max - min;
                bool flag2 = num == 0f;
                if (flag2)
                {
                    num = 1f;
                }
                result = height - (value - min) / num * height;
            }
            return result;
        }

        /// <summary>
        /// 计算绘图X轴时的相对偏移值
        /// </summary>
        /// <param name="max">0-100分的最大值，就是指准备绘制的最大值</param>
        /// <param name="min">0-100分的最小值，就是指准备绘制的最小值</param>
        /// <param name="width">实际绘图区域的宽度</param>
        /// <param name="value">需要绘制数据的当前值</param>
        /// <returns>相对于0的位置，还需要增加上面的偏值</returns>
        // Token: 0x060004E4 RID: 1252 RVA: 0x00032FF0 File Offset: 0x000311F0
        public static float ComputePaintLocationX(float max, float min, float width, float value)
        {
            bool flag = max - min == 0f;
            float result;
            if (flag)
            {
                result = width;
            }
            else
            {
                float num = max - min;
                bool flag2 = num == 0f;
                if (flag2)
                {
                    num = 1f;
                }
                result = (value - min) / num * width;
            }
            return result;
        }

        /// <summary>
        /// 根据绘制的值计算原始的值信息
        /// </summary>
        /// <param name="max">0-100分的最大值，就是指准备绘制的最大值</param>
        /// <param name="min">0-100分的最小值，就是指准备绘制的最小值</param>
        /// <param name="height">实际绘图区域的高度</param>
        /// <param name="paint">实际绘制的位置信息</param>
        /// <returns>实际的值信息</returns>
        // Token: 0x060004E5 RID: 1253 RVA: 0x00033034 File Offset: 0x00031234
        public static float ComputeValueFromPaintLocationY(float max, float min, float height, float paint)
        {
            bool flag = max - min == 0f;
            float result;
            if (flag)
            {
                result = max;
            }
            else
            {
                float num = max - min;
                bool flag2 = num == 0f;
                if (flag2)
                {
                    num = 1f;
                }
                result = (height - paint) * num / height + min;
            }
            return result;
        }

        /// <summary>
        /// 计算绘图时的相对偏移值
        /// </summary>
        /// <param name="referenceAxis">坐标轴信息</param>
        /// <param name="height">实际绘图区域的高度</param>
        /// <param name="value">需要绘制数据的当前值</param>
        /// <returns>相对于0的位置，还需要增加上面的偏值</returns>
        // Token: 0x060004E6 RID: 1254 RVA: 0x0003307C File Offset: 0x0003127C
        public static float ComputePaintLocationY(ReferenceAxis referenceAxis, float height, float value)
        {
            return HslHelper.ComputePaintLocationY(referenceAxis.Max, referenceAxis.Min, height, value);
        }

        /// <summary>
        /// 绘制坐标系中的刻度线
        /// </summary>
        /// <param name="g">绘图对象</param>
        /// <param name="penLine">画坐标轴的画笔</param>
        /// <param name="penDash"></param>
        /// <param name="font"></param>
        /// <param name="brush"></param>
        /// <param name="sf"></param>
        /// <param name="degree"></param>
        /// <param name="max"></param>
        /// <param name="min"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="up"></param>
        /// <param name="down"></param>
        // Token: 0x060004E7 RID: 1255 RVA: 0x000330A4 File Offset: 0x000312A4
        public static void PaintCoordinateDivide(Graphics g, System.Drawing.Pen penLine, System.Drawing.Pen penDash, Font font, System.Drawing.Brush brush, StringFormat sf, int degree, int max, int min, int width, int height, int left = 60, int right = 8, int up = 8, int down = 8)
        {
            for (int i = 0; i <= degree; i++)
            {
                int value = (max - min) * i / degree + min;
                int num = (int)HslHelper.ComputePaintLocationY(max, min, height - up - down, value) + up + 1;
                g.DrawLine(penLine, left - 1, num, left - 4, num);
                bool flag = i != 0;
                if (flag)
                {
                    g.DrawLine(penDash, left, num, width - right, num);
                }
                g.DrawString(value.ToString(), font, brush, new Rectangle(-5, num - font.Height / 2, left, font.Height), sf);
            }
        }

        /// <summary>
        /// 根据指定的方向绘制一个箭头
        /// </summary>
        /// <param name="g"></param>
        /// <param name="brush"></param>
        /// <param name="point"></param>
        /// <param name="size"></param>
        /// <param name="direction"></param>
        // Token: 0x060004E8 RID: 1256 RVA: 0x00033158 File Offset: 0x00031358
        public static void PaintTriangle(Graphics g, System.Drawing.Brush brush, Point point, int size, GraphDirection direction)
        {
            Point[] array = new Point[4];
            bool flag = direction == GraphDirection.Leftward;
            if (flag)
            {
                array[0] = new Point(point.X, point.Y - size);
                array[1] = new Point(point.X, point.Y + size);
                array[2] = new Point(point.X - 2 * size, point.Y);
            }
            else
            {
                bool flag2 = direction == GraphDirection.Rightward;
                if (flag2)
                {
                    array[0] = new Point(point.X, point.Y - size);
                    array[1] = new Point(point.X, point.Y + size);
                    array[2] = new Point(point.X + 2 * size, point.Y);
                }
                else
                {
                    bool flag3 = direction == GraphDirection.Upward;
                    if (flag3)
                    {
                        array[0] = new Point(point.X - size, point.Y);
                        array[1] = new Point(point.X + size, point.Y);
                        array[2] = new Point(point.X, point.Y - 2 * size);
                    }
                    else
                    {
                        array[0] = new Point(point.X - size, point.Y);
                        array[1] = new Point(point.X + size, point.Y);
                        array[2] = new Point(point.X, point.Y + 2 * size);
                    }
                }
            }
            array[3] = array[0];
            g.FillPolygon(brush, array);
        }

        /// <summary>
        /// 绘制向左或是向右的箭头，例如 &lt;&lt;  或是 &gt;&gt;
        /// </summary>
        /// <param name="g">画刷资源</param>
        /// <param name="pen">画笔资源</param>
        /// <param name="rectangle">绘制的矩形</param>
        /// <param name="direction">方向信息</param>
        // Token: 0x060004E9 RID: 1257 RVA: 0x0003330C File Offset: 0x0003150C
        public static void DrawLeftRight(Graphics g, System.Drawing.Pen pen, Rectangle rectangle, GraphDirection direction)
        {
            bool flag = direction == GraphDirection.Leftward;
            if (flag)
            {
                g.DrawLines(pen, new Point[]
                {
                    new Point(rectangle.X + rectangle.Width / 2, rectangle.Y),
                    new Point(rectangle.X, rectangle.Y + rectangle.Height / 2),
                    new Point(rectangle.X + rectangle.Width / 2, rectangle.Y + rectangle.Height)
                });
                g.DrawLines(pen, new Point[]
                {
                    new Point(rectangle.X + rectangle.Width, rectangle.Y),
                    new Point(rectangle.X + rectangle.Width / 2, rectangle.Y + rectangle.Height / 2),
                    new Point(rectangle.X + rectangle.Width, rectangle.Y + rectangle.Height)
                });
            }
            else
            {
                bool flag2 = direction == GraphDirection.Rightward;
                if (flag2)
                {
                    g.DrawLines(pen, new Point[]
                    {
                        new Point(rectangle.X, rectangle.Y),
                        new Point(rectangle.X + rectangle.Width / 2, rectangle.Y + rectangle.Height / 2),
                        new Point(rectangle.X, rectangle.Y + rectangle.Height)
                    });
                    g.DrawLines(pen, new Point[]
                    {
                        new Point(rectangle.X + rectangle.Width / 2, rectangle.Y),
                        new Point(rectangle.X + rectangle.Width, rectangle.Y + rectangle.Height / 2),
                        new Point(rectangle.X + rectangle.Width / 2, rectangle.Y + rectangle.Height)
                    });
                }
            }
        }

        /// <summary>
        /// 根据指定的方向绘制一个箭头
        /// </summary>
        /// <param name="g"></param>
        /// <param name="brush"></param>
        /// <param name="point"></param>
        /// <param name="size"></param>
        /// <param name="direction"></param>
        // Token: 0x060004EA RID: 1258 RVA: 0x00033548 File Offset: 0x00031748
        public static void PaintTriangle(Graphics g, System.Drawing.Brush brush, PointF point, int size, GraphDirection direction)
        {
            PointF[] array = new PointF[4];
            bool flag = direction == GraphDirection.Leftward;
            if (flag)
            {
                array[0] = new PointF(point.X, point.Y - (float)size);
                array[1] = new PointF(point.X, point.Y + (float)size);
                array[2] = new PointF(point.X - (float)(2 * size), point.Y);
            }
            else
            {
                bool flag2 = direction == GraphDirection.Rightward;
                if (flag2)
                {
                    array[0] = new PointF(point.X, point.Y - (float)size);
                    array[1] = new PointF(point.X, point.Y + (float)size);
                    array[2] = new PointF(point.X + (float)(2 * size), point.Y);
                }
                else
                {
                    bool flag3 = direction == GraphDirection.Upward;
                    if (flag3)
                    {
                        array[0] = new PointF(point.X - (float)size, point.Y);
                        array[1] = new PointF(point.X + (float)size, point.Y);
                        array[2] = new PointF(point.X, point.Y - (float)(2 * size));
                    }
                    else
                    {
                        array[0] = new PointF(point.X - (float)size, point.Y);
                        array[1] = new PointF(point.X + (float)size, point.Y);
                        array[2] = new PointF(point.X, point.Y + (float)(2 * size));
                    }
                }
            }
            array[3] = array[0];
            g.FillPolygon(brush, array);
        }

        /// <summary>
        /// 一个通用的数组新增个数方法，会自动判断越界情况，越界的情况下，会自动的截断或是填充 -&gt; 
        /// A common array of new methods, will automatically determine the cross-border situation, in the case of cross-border, will be automatically truncated or filled
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="array">原数据</param>
        /// <param name="data">等待新增的数据</param>
        /// <param name="max">原数据的最大值</param>
        // Token: 0x060004EB RID: 1259 RVA: 0x00033708 File Offset: 0x00031908
        public static void AddArrayData<T>(ref T[] array, T[] data, int max)
        {
            bool flag = data == null;
            if (!flag)
            {
                bool flag2 = data.Length == 0;
                if (!flag2)
                {
                    bool flag3 = array.Length == max;
                    if (flag3)
                    {
                        Array.Copy(array, data.Length, array, 0, array.Length - data.Length);
                        Array.Copy(data, 0, array, array.Length - data.Length, data.Length);
                    }
                    else
                    {
                        bool flag4 = array.Length + data.Length > max;
                        if (flag4)
                        {
                            T[] array2 = new T[max];
                            for (int i = 0; i < max - data.Length; i++)
                            {
                                array2[i] = array[i + (array.Length - max + data.Length)];
                            }
                            for (int j = 0; j < data.Length; j++)
                            {
                                array2[array2.Length - data.Length + j] = data[j];
                            }
                            array = array2;
                        }
                        else
                        {
                            T[] array3 = new T[array.Length + data.Length];
                            for (int k = 0; k < array.Length; k++)
                            {
                                array3[k] = array[k];
                            }
                            for (int l = 0; l < data.Length; l++)
                            {
                                array3[array3.Length - data.Length + l] = data[l];
                            }
                            array = array3;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 尺寸转换，计算旋转后的尺寸。
        /// </summary>
        /// <param name="size"></param>
        /// <param name="angle"></param>
        /// <returns></returns>
        // Token: 0x060004EC RID: 1260 RVA: 0x00033874 File Offset: 0x00031A74
        public static SizeF ConvertSize(SizeF size, float angle)
        {
            System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
            matrix.Rotate(angle);
            PointF[] array = new PointF[4];
            array[0].X = -size.Width / 2f;
            array[0].Y = -size.Height / 2f;
            array[1].X = -size.Width / 2f;
            array[1].Y = size.Height / 2f;
            array[2].X = size.Width / 2f;
            array[2].Y = size.Height / 2f;
            array[3].X = size.Width / 2f;
            array[3].Y = -size.Height / 2f;
            matrix.TransformPoints(array);
            float num = float.MaxValue;
            float num2 = float.MinValue;
            float num3 = float.MaxValue;
            float num4 = float.MinValue;
            foreach (PointF pointF in array)
            {
                bool flag = pointF.X < num;
                if (flag)
                {
                    num = pointF.X;
                }
                bool flag2 = pointF.X > num2;
                if (flag2)
                {
                    num2 = pointF.X;
                }
                bool flag3 = pointF.Y < num3;
                if (flag3)
                {
                    num3 = pointF.Y;
                }
                bool flag4 = pointF.Y > num4;
                if (flag4)
                {
                    num4 = pointF.Y;
                }
            }
            SizeF result = new SizeF(num2 - num, num4 - num3);
            return result;
        }

        /// <summary>
        /// 绘制旋转文本
        /// </summary>
        /// <param name="g"></param>
        /// <param name="s"></param>
        /// <param name="font"></param>
        /// <param name="brush"></param>
        /// <param name="point"></param>
        /// <param name="format"></param>
        /// <param name="angle"></param>
        // Token: 0x060004ED RID: 1261 RVA: 0x00033A2C File Offset: 0x00031C2C
        public static void DrawString(Graphics g, string s, Font font, System.Drawing.Brush brush, PointF point, StringFormat format, float angle)
        {
            System.Drawing.Drawing2D.Matrix transform = g.Transform;
            System.Drawing.Drawing2D.Matrix transform2 = g.Transform;
            transform2.RotateAt(angle, point);
            g.Transform = transform2;
            g.DrawString(s, font, brush, point, format);
            g.Transform = transform;
        }

        // Token: 0x060004EE RID: 1262 RVA: 0x00033A74 File Offset: 0x00031C74
        private static int GetPow(int digit)
        {
            int num = 1;
            for (int i = 0; i < digit; i++)
            {
                num *= 10;
            }
            return num;
        }

        /// <summary>
        /// 将int数组转换为double数组
        /// </summary>
        /// <param name="values">int数组值</param>
        /// <returns>结果值</returns>
        // Token: 0x060004EF RID: 1263 RVA: 0x00033AA0 File Offset: 0x00031CA0
        public static double[] TranlateArrayToDouble(int[] values)
        {
            bool flag = values == null;
            double[] result;
            if (flag)
            {
                result = null;
            }
            else
            {
                double[] array = new double[values.Length];
                for (int i = 0; i < values.Length; i++)
                {
                    array[i] = (double)values[i];
                }
                result = array;
            }
            return result;
        }

        /// <summary>
        /// 将float数组转换为double数组值
        /// </summary>
        /// <param name="values">float数组值</param>
        /// <returns>结果值</returns>
        // Token: 0x060004F0 RID: 1264 RVA: 0x00033AE8 File Offset: 0x00031CE8
        public static double[] TranlateArrayToDouble(float[] values)
        {
            double[] array = new double[values.Length];
            for (int i = 0; i < values.Length; i++)
            {
                array[i] = (double)values[i];
            }
            return array;
        }

        /// <summary>
        /// 获得数据的上限值，这个上限值是自动计算的。
        /// </summary>
        /// <param name="values">数据值</param>
        /// <returns>数据值</returns>
        // Token: 0x060004F1 RID: 1265 RVA: 0x00033B20 File Offset: 0x00031D20
        public static int CalculateMaxSectionFrom(double[] values)
        {
            double num = values.Max();
            bool flag = num <= 5.0;
            int result;
            if (flag)
            {
                result = 5;
            }
            else
            {
                bool flag2 = num <= 9.0;
                if (flag2)
                {
                    result = 10;
                }
                else
                {
                    int num2 = Convert.ToInt32(Math.Ceiling(num));
                    int digit = num2.ToString().Length - 2;
                    int num3 = int.Parse(num2.ToString().Substring(0, 2));
                    bool flag3 = num3 < 11;
                    if (flag3)
                    {
                        result = 12 * HslHelper.GetPow(digit);
                    }
                    else
                    {
                        bool flag4 = num3 < 13;
                        if (flag4)
                        {
                            result = 14 * HslHelper.GetPow(digit);
                        }
                        else
                        {
                            bool flag5 = num3 < 15;
                            if (flag5)
                            {
                                result = 16 * HslHelper.GetPow(digit);
                            }
                            else
                            {
                                bool flag6 = num3 < 17;
                                if (flag6)
                                {
                                    result = 18 * HslHelper.GetPow(digit);
                                }
                                else
                                {
                                    bool flag7 = num3 < 19;
                                    if (flag7)
                                    {
                                        result = 20 * HslHelper.GetPow(digit);
                                    }
                                    else
                                    {
                                        bool flag8 = num3 < 21;
                                        if (flag8)
                                        {
                                            result = 22 * HslHelper.GetPow(digit);
                                        }
                                        else
                                        {
                                            bool flag9 = num3 < 23;
                                            if (flag9)
                                            {
                                                result = 24 * HslHelper.GetPow(digit);
                                            }
                                            else
                                            {
                                                bool flag10 = num3 < 25;
                                                if (flag10)
                                                {
                                                    result = 26 * HslHelper.GetPow(digit);
                                                }
                                                else
                                                {
                                                    bool flag11 = num3 < 27;
                                                    if (flag11)
                                                    {
                                                        result = 28 * HslHelper.GetPow(digit);
                                                    }
                                                    else
                                                    {
                                                        bool flag12 = num3 < 29;
                                                        if (flag12)
                                                        {
                                                            result = 30 * HslHelper.GetPow(digit);
                                                        }
                                                        else
                                                        {
                                                            bool flag13 = num3 < 33;
                                                            if (flag13)
                                                            {
                                                                result = 34 * HslHelper.GetPow(digit);
                                                            }
                                                            else
                                                            {
                                                                bool flag14 = num3 < 40;
                                                                if (flag14)
                                                                {
                                                                    result = 40 * HslHelper.GetPow(digit);
                                                                }
                                                                else
                                                                {
                                                                    bool flag15 = num3 < 50;
                                                                    if (flag15)
                                                                    {
                                                                        result = 50 * HslHelper.GetPow(digit);
                                                                    }
                                                                    else
                                                                    {
                                                                        bool flag16 = num3 < 60;
                                                                        if (flag16)
                                                                        {
                                                                            result = 60 * HslHelper.GetPow(digit);
                                                                        }
                                                                        else
                                                                        {
                                                                            bool flag17 = num3 < 80;
                                                                            if (flag17)
                                                                            {
                                                                                result = 80 * HslHelper.GetPow(digit);
                                                                            }
                                                                            else
                                                                            {
                                                                                bool flag18 = num3 < 95;
                                                                                if (flag18)
                                                                                {
                                                                                    result = 100 * HslHelper.GetPow(digit);
                                                                                }
                                                                                else
                                                                                {
                                                                                    result = 100 * HslHelper.GetPow(digit);
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return result;
        }

        /// <inheritdoc cref="M:HslControls.HslHelper.CalculateMaxSectionFrom(System.Double[])" />
        // Token: 0x060004F2 RID: 1266 RVA: 0x00033D50 File Offset: 0x00031F50
        public static int CalculateMaxSectionFrom(Dictionary<string, double[]> values)
        {
            return HslHelper.CalculateMaxSectionFrom((from m in values
                                                      select m.Value.Max()).ToArray<double>());
        }

        /// <summary>
        /// 获取当前颜色更淡的颜色信息
        /// </summary>
        /// <param name="color">颜色信息</param>
        /// <returns>颜色</returns>
        // Token: 0x060004F3 RID: 1267 RVA: 0x00033D94 File Offset: 0x00031F94
        public static System.Drawing.Color GetColorLight(System.Drawing.Color color)
        {
            return HslHelper.GetColorLight(color, 40);
        }

        /// <summary>
        /// 获取当前颜色更深的颜色信息
        /// </summary>
        /// <param name="color">颜色信息</param>
        /// <returns>颜色</returns>
        // Token: 0x060004F4 RID: 1268 RVA: 0x00033DB0 File Offset: 0x00031FB0
        public static System.Drawing.Color GetColorDeep(System.Drawing.Color color)
        {
            return HslHelper.GetColorLight(color, -40);
        }

        /// <summary>
        /// 获取当前颜色更淡的颜色信息，需要指定系数0-100，0时是原来的原色，100时是纯白色
        /// </summary>
        /// <param name="color">颜色信息</param>
        /// <param name="scale">获取颜色的系数信息</param>
        /// <returns>颜色</returns>
        // Token: 0x060004F5 RID: 1269 RVA: 0x00033DCC File Offset: 0x00031FCC
        public static System.Drawing.Color GetColorLight(System.Drawing.Color color, int scale)
        {
            bool flag = scale > 0;
            System.Drawing.Color result;
            if (flag)
            {
                result = System.Drawing.Color.FromArgb((int)color.R + (int)(byte.MaxValue - color.R) * scale / 100, (int)color.G + (int)(byte.MaxValue - color.G) * scale / 100, (int)color.B + (int)(byte.MaxValue - color.B) * scale / 100);
            }
            else
            {
                result = System.Drawing.Color.FromArgb((int)color.R + (int)color.R * scale / 100, (int)color.G + (int)color.G * scale / 100, (int)color.B + (int)color.B * scale / 100);
            }
            return result;
        }

        /// <summary>
        /// 获取颜色的偏移信息
        /// </summary>
        /// <param name="color">颜色值</param>
        /// <param name="offset">颜色偏移信息</param>
        /// <returns>颜色值</returns>
        // Token: 0x060004F6 RID: 1270 RVA: 0x00033E80 File Offset: 0x00032080
        public static System.Drawing.Color GetColorOffset(System.Drawing.Color color, int offset)
        {
            int num = (int)color.R + offset;
            bool flag = num < 0;
            if (flag)
            {
                num = 0;
            }
            bool flag2 = num > 255;
            if (flag2)
            {
                num = 255;
            }
            int num2 = (int)color.G + offset;
            bool flag3 = num2 < 0;
            if (flag3)
            {
                num2 = 0;
            }
            bool flag4 = num2 > 255;
            if (flag4)
            {
                num2 = 255;
            }
            int num3 = (int)color.B + offset;
            bool flag5 = num3 < 0;
            if (flag5)
            {
                num3 = 0;
            }
            bool flag6 = num3 > 255;
            if (flag6)
            {
                num3 = 255;
            }
            return System.Drawing.Color.FromArgb(num, num2, num3);
        }

        /// <summary>
        /// 获取当前颜色更淡的颜色信息
        /// </summary>
        /// <param name="color">颜色信息</param>
        /// <returns>颜色</returns>
        // Token: 0x060004F7 RID: 1271 RVA: 0x00033F18 File Offset: 0x00032118
        public static System.Drawing.Color GetColorLightFive(System.Drawing.Color color)
        {
            return HslHelper.GetColorLight(color, 50);
        }


        /// <summary>
        /// 从字符串表示的点位信息里解析出真正的点位信息
        /// </summary>
        /// <param name="points">字符串的点位</param>
        /// <param name="soureWidth">原来的长度信息</param>
        /// <param name="sourceHeight">原来的高度信息</param>
        /// <param name="width">实际的宽度信息</param>
        /// <param name="height">实际的高度信息</param>
        /// <param name="dx">x偏移量信息</param>
        /// <param name="dy">y偏移量信息</param>
        /// <returns></returns>
        // Token: 0x060004FA RID: 1274 RVA: 0x0003400C File Offset: 0x0003220C
        public static PointF[] GetPointsFrom(string points, float soureWidth, float sourceHeight, float width, float height, float dx = 0f, float dy = 0f)
        {
            string[] array = points.Split(new char[]
            {
                ' '
            }, StringSplitOptions.RemoveEmptyEntries);
            PointF[] array2 = new PointF[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                int num = array[i].IndexOf(',');
                float num2 = Convert.ToSingle(array[i].Substring(0, num));
                float num3 = Convert.ToSingle(array[i].Substring(num + 1));
                array2[i] = new PointF(width * (num2 + dx) / soureWidth, height * (num3 + dy) / sourceHeight);
            }
            return array2;
        }

        /// <summary>
        /// 根据矩形及其各个定点的配置信息，获取圆角的路径信息，可以指定每个定点的圆角情况
        /// </summary>
        /// <param name="rectangle"></param>
        /// <param name="radius"></param>
        /// <param name="topLeft"></param>
        /// <param name="topRight"></param>
        /// <param name="buttomRight"></param>
        /// <param name="buttomLeft"></param>
        /// <returns></returns>
        // Token: 0x060004FB RID: 1275 RVA: 0x000340A0 File Offset: 0x000322A0
        public static GraphicsPath GetRoundRectange(Rectangle rectangle, int radius, bool topLeft, bool topRight, bool buttomRight, bool buttomLeft)
        {
            GraphicsPath graphicsPath = new GraphicsPath();
            Point pt = new Point(rectangle.X + (topLeft ? radius : 0), rectangle.Y);
            Point pt2 = new Point(rectangle.X + rectangle.Width - 1 - (topRight ? radius : 0), rectangle.Y);
            graphicsPath.AddLine(pt, pt2);
            bool flag = topRight && radius > 0;
            if (flag)
            {
                graphicsPath.AddArc(rectangle.X + rectangle.Width - radius * 2 - 1, rectangle.Y, radius * 2, radius * 2, 270f, 90f);
            }
            Point pt3 = new Point(rectangle.X + rectangle.Width - 1, rectangle.Y + (topRight ? radius : 0));
            Point pt4 = new Point(rectangle.X + rectangle.Width - 1, rectangle.Y + rectangle.Height - 1 - (buttomRight ? radius : 0));
            graphicsPath.AddLine(pt3, pt4);
            bool flag2 = buttomRight && radius > 0;
            if (flag2)
            {
                graphicsPath.AddArc(rectangle.X + rectangle.Width - radius * 2 - 1, rectangle.Y + rectangle.Height - radius * 2 - 1, radius * 2, radius * 2, 0f, 90f);
            }
            Point pt5 = new Point(rectangle.X + rectangle.Width - 1 - (buttomRight ? radius : 0), rectangle.Y + rectangle.Height - 1);
            Point pt6 = new Point(rectangle.X + (buttomLeft ? radius : 0), rectangle.Y + rectangle.Height - 1);
            graphicsPath.AddLine(pt5, pt6);
            bool flag3 = buttomLeft && radius > 0;
            if (flag3)
            {
                graphicsPath.AddArc(rectangle.X, rectangle.Y + rectangle.Height - radius * 2 - 1, radius * 2, radius * 2, 90f, 90f);
            }
            Point pt7 = new Point(rectangle.X, rectangle.Y + rectangle.Height - 1 - (buttomLeft ? radius : 0));
            Point pt8 = new Point(rectangle.X, rectangle.Y + (topLeft ? radius : 0));
            graphicsPath.AddLine(pt7, pt8);
            bool flag4 = topLeft && radius > 0;
            if (flag4)
            {
                graphicsPath.AddArc(rectangle.X, rectangle.Y, radius * 2, radius * 2, 180f, 90f);
            }
            return graphicsPath;
        }

        // Token: 0x060004FC RID: 1276 RVA: 0x00034330 File Offset: 0x00032530
        private static string FloatMatchEvaluator(Match m)
        {
            bool flag = m.Value.Length == 5;
            string result;
            if (flag)
            {
                result = m.Value.Substring(0, 3);
            }
            else
            {
                result = m.Value.Substring(0, 2);
            }
            return result;
        }

        // Token: 0x060004FD RID: 1277 RVA: 0x00034374 File Offset: 0x00032574
        private static string RemoveEndWithZero(string value)
        {
            return Regex.Replace(value, "\\.[0]+$", "");
        }

        // Token: 0x060004FE RID: 1278 RVA: 0x00034398 File Offset: 0x00032598
        public static float GetReferenceAxisMaxValue(float max)
        {
            bool flag = max >= 0f;
            float result;
            if (flag)
            {
                int floatPow = HslHelper.GetFloatPow(max);
                float num = (float)((double)max * Math.Pow(10.0, (double)(-(double)floatPow)));
                bool flag2 = num == 0f;
                if (flag2)
                {
                    result = 1f;
                }
                else
                {
                    bool flag3 = num < 1.1f;
                    if (flag3)
                    {
                        result = Convert.ToSingle(1.2000000476837158 * Math.Pow(10.0, (double)floatPow));
                    }
                    else
                    {
                        bool flag4 = num < 1.3f;
                        if (flag4)
                        {
                            result = Convert.ToSingle(1.399999976158142 * Math.Pow(10.0, (double)floatPow));
                        }
                        else
                        {
                            bool flag5 = num < 1.5f;
                            if (flag5)
                            {
                                result = Convert.ToSingle(1.600000023841858 * Math.Pow(10.0, (double)floatPow));
                            }
                            else
                            {
                                bool flag6 = num < 1.7f;
                                if (flag6)
                                {
                                    result = Convert.ToSingle(1.7999999523162842 * Math.Pow(10.0, (double)floatPow));
                                }
                                else
                                {
                                    bool flag7 = num < 1.9f;
                                    if (flag7)
                                    {
                                        result = Convert.ToSingle(2.0 * Math.Pow(10.0, (double)floatPow));
                                    }
                                    else
                                    {
                                        bool flag8 = num < 2.2f;
                                        if (flag8)
                                        {
                                            result = Convert.ToSingle(2.4000000953674316 * Math.Pow(10.0, (double)floatPow));
                                        }
                                        else
                                        {
                                            bool flag9 = num < 2.4f;
                                            if (flag9)
                                            {
                                                result = Convert.ToSingle(2.5999999046325684 * Math.Pow(10.0, (double)floatPow));
                                            }
                                            else
                                            {
                                                bool flag10 = num < 2.6f;
                                                if (flag10)
                                                {
                                                    result = Convert.ToSingle(2.799999952316284 * Math.Pow(10.0, (double)floatPow));
                                                }
                                                else
                                                {
                                                    bool flag11 = num < 2.8f;
                                                    if (flag11)
                                                    {
                                                        result = Convert.ToSingle(3.0 * Math.Pow(10.0, (double)floatPow));
                                                    }
                                                    else
                                                    {
                                                        bool flag12 = num < 3.3f;
                                                        if (flag12)
                                                        {
                                                            result = Convert.ToSingle(3.5 * Math.Pow(10.0, (double)floatPow));
                                                        }
                                                        else
                                                        {
                                                            bool flag13 = num < 3.8f;
                                                            if (flag13)
                                                            {
                                                                result = Convert.ToSingle(4.0 * Math.Pow(10.0, (double)floatPow));
                                                            }
                                                            else
                                                            {
                                                                bool flag14 = num < 4.5f;
                                                                if (flag14)
                                                                {
                                                                    result = Convert.ToSingle(5.0 * Math.Pow(10.0, (double)floatPow));
                                                                }
                                                                else
                                                                {
                                                                    bool flag15 = num < 6.5f;
                                                                    if (flag15)
                                                                    {
                                                                        result = Convert.ToSingle(6.0 * Math.Pow(10.0, (double)floatPow));
                                                                    }
                                                                    else
                                                                    {
                                                                        bool flag16 = num < 7.5f;
                                                                        if (flag16)
                                                                        {
                                                                            result = Convert.ToSingle(8.0 * Math.Pow(10.0, (double)floatPow));
                                                                        }
                                                                        else
                                                                        {
                                                                            bool flag17 = num < 9.5f;
                                                                            if (flag17)
                                                                            {
                                                                                result = Convert.ToSingle(10.0 * Math.Pow(10.0, (double)floatPow));
                                                                            }
                                                                            else
                                                                            {
                                                                                result = Convert.ToSingle(12.0 * Math.Pow(10.0, (double)floatPow));
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                int floatPow2 = HslHelper.GetFloatPow(-max);
                float num2 = (float)((double)max * Math.Pow(10.0, (double)(-(double)floatPow2)));
                bool flag18 = num2 < -8.5f;
                if (flag18)
                {
                    result = Convert.ToSingle(-8.0 * Math.Pow(10.0, (double)floatPow2));
                }
                else
                {
                    bool flag19 = num2 < -6.5f;
                    if (flag19)
                    {
                        result = Convert.ToSingle(-6.0 * Math.Pow(10.0, (double)floatPow2));
                    }
                    else
                    {
                        bool flag20 = num2 < -4.5f;
                        if (flag20)
                        {
                            result = Convert.ToSingle(-4.0 * Math.Pow(10.0, (double)floatPow2));
                        }
                        else
                        {
                            bool flag21 = num2 < -3.5f;
                            if (flag21)
                            {
                                result = Convert.ToSingle(-3.0 * Math.Pow(10.0, (double)floatPow2));
                            }
                            else
                            {
                                bool flag22 = num2 < -2.2f;
                                if (flag22)
                                {
                                    result = Convert.ToSingle(-2.0 * Math.Pow(10.0, (double)floatPow2));
                                }
                                else
                                {
                                    bool flag23 = num2 < -1.9f;
                                    if (flag23)
                                    {
                                        result = Convert.ToSingle(-1.7999999523162842 * Math.Pow(10.0, (double)floatPow2));
                                    }
                                    else
                                    {
                                        bool flag24 = num2 < -1.7f;
                                        if (flag24)
                                        {
                                            result = Convert.ToSingle(-1.600000023841858 * Math.Pow(10.0, (double)floatPow2));
                                        }
                                        else
                                        {
                                            bool flag25 = num2 < -1.5f;
                                            if (flag25)
                                            {
                                                result = Convert.ToSingle(-1.399999976158142 * Math.Pow(10.0, (double)floatPow2));
                                            }
                                            else
                                            {
                                                bool flag26 = num2 < -1.3f;
                                                if (flag26)
                                                {
                                                    result = Convert.ToSingle(-1.2000000476837158 * Math.Pow(10.0, (double)floatPow2));
                                                }
                                                else
                                                {
                                                    result = Convert.ToSingle(-1.0 * Math.Pow(10.0, (double)floatPow2));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return result;
        }

        // Token: 0x060004FF RID: 1279 RVA: 0x00034948 File Offset: 0x00032B48
        private static int GetFloatPow(float value)
        {
            bool flag = value >= 1f && value < 10f;
            int result;
            if (flag)
            {
                result = 0;
            }
            else
            {
                bool flag2 = value >= 10f;
                if (flag2)
                {
                    result = HslHelper.GetFloatPow(value / 10f) + 1;
                }
                else
                {
                    bool flag3 = value > 0f && value < 1f;
                    if (flag3)
                    {
                        result = HslHelper.GetFloatPow(value * 10f) - 1;
                    }
                    else
                    {
                        result = 0;
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 获取浮点数值的格式化文本信息，如果发生了异常，则返回错误消息
        /// </summary>
        /// <param name="format">格式化信息</param>
        /// <param name="value">值信息</param>
        /// <param name="remainZero">是否保留0的信息</param>
        /// <returns>等待显示的文本</returns>
        // Token: 0x06000500 RID: 1280 RVA: 0x000349C0 File Offset: 0x00032BC0
        public static string GetFormatString(string format, float value, bool remainZero = false)
        {
            string result;
            try
            {
                string text = string.Format(format, value);
                if (remainZero)
                {
                    result = HslHelper.RemoveEndWithZero(text);
                }
                else
                {
                    result = HslHelper.RemoveEndWithZero(Regex.Replace(text, "[Ee][+-][0]+", new MatchEvaluator(HslHelper.FloatMatchEvaluator)));
                }
            }
            catch
            {
                result = "Wrong";
            }
            return result;
        }

        /// <summary>
        /// 矩形中间的字符串对齐机制
        /// </summary>
        // Token: 0x17000181 RID: 385
        // (get) Token: 0x06000501 RID: 1281 RVA: 0x00034A24 File Offset: 0x00032C24
        // (set) Token: 0x06000502 RID: 1282 RVA: 0x00034A2B File Offset: 0x00032C2B
        public static StringFormat StringFormatCenter { get; set; }

        /// <summary>
        /// 矩形的左侧中间的对齐机制
        /// </summary>
        // Token: 0x17000182 RID: 386
        // (get) Token: 0x06000503 RID: 1283 RVA: 0x00034A33 File Offset: 0x00032C33
        // (set) Token: 0x06000504 RID: 1284 RVA: 0x00034A3A File Offset: 0x00032C3A
        public static StringFormat StringFormatLeft { get; set; }

        /// <summary>
        /// 矩形的右侧的中间对齐机制
        /// </summary>
        // Token: 0x17000183 RID: 387
        // (get) Token: 0x06000505 RID: 1285 RVA: 0x00034A42 File Offset: 0x00032C42
        // (set) Token: 0x06000506 RID: 1286 RVA: 0x00034A49 File Offset: 0x00032C49
        public static StringFormat StringFormatRight { get; set; }

        /// <summary>
        /// 矩形的的默认的左上角对齐的机制
        /// </summary>
        // Token: 0x17000184 RID: 388
        // (get) Token: 0x06000507 RID: 1287 RVA: 0x00034A51 File Offset: 0x00032C51
        // (set) Token: 0x06000508 RID: 1288 RVA: 0x00034A58 File Offset: 0x00032C58
        public static StringFormat StringFormatDefault { get; set; } = new StringFormat();

        /// <summary>
        /// 矩形的下方中间的对齐的机制
        /// </summary>
        // Token: 0x17000185 RID: 389
        // (get) Token: 0x06000509 RID: 1289 RVA: 0x00034A60 File Offset: 0x00032C60
        // (set) Token: 0x0600050A RID: 1290 RVA: 0x00034A67 File Offset: 0x00032C67
        public static StringFormat StringFormatTopCenter { get; set; }
    }
}