/// <summary>
        /// Constructor
        /// </summary>
        public ctrlVerticalColorSlider()
        {
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();

            //	Initialize Colors
            m_hsl        = new AdobeColors.HSL();
            m_hsl.H      = 1.0;
            m_hsl.S      = 1.0;
            m_hsl.L      = 1.0;
            m_rgb        = AdobeColors.HSL_to_RGB(m_hsl);
            m_eDrawStyle = eDrawStyle.Hue;
        }
        /// <summary>
        /// Fills in the content of the control showing all values of Luminance (0 to 100%) for the given
        /// Hue and Saturation.
        /// </summary>
        private void Draw_Style_Luminance()
        {
            Graphics g = this.CreateGraphics();

            AdobeColors.HSL _hsl = new AdobeColors.HSL();
            _hsl.H = m_hsl.H;                   //	Use the H and S values of the current color (m_hsl)
            _hsl.S = m_hsl.S;

            for (int i = 0; i < this.Height - 8; i++)               //	i represents the current line of pixels we want to draw horizontally
            {
                _hsl.L = 1.0 - (double)i / (this.Height - 8);       //	L (Luminance) is based on the current vertical position
                Pen pen = new Pen(AdobeColors.HSL_to_RGB(_hsl));    //	Get the Color for this line

                g.DrawLine(pen, 11, i + 4, this.Width - 11, i + 4); //	Draw the line and loop back for next line
            }
        }
        //	The following functions do the real work of the control, drawing the primary content (the area between the slider)
        //

        /// <summary>
        /// Fills in the content of the control showing all values of Hue (from 0 to 360)
        /// </summary>
        private void Draw_Style_Hue()
        {
            Graphics g = this.CreateGraphics();

            AdobeColors.HSL _hsl = new AdobeColors.HSL();
            _hsl.S = 1.0;               //	S and L will both be at 100% for this DrawStyle
            _hsl.L = 1.0;

            for (int i = 0; i < this.Height - 8; i++)                   //	i represents the current line of pixels we want to draw horizontally
            {
                _hsl.H = 1.0 - (double)i / (this.Height - 8);           //	H (hue) is based on the current vertical position
                Pen pen = new Pen(AdobeColors.HSL_to_RGB(_hsl));        //	Get the Color for this line

                g.DrawLine(pen, 11, i + 4, this.Width - 11, i + 4);     //	Draw the line and loop back for next line
            }
        }
        /// <summary>
        /// Resets the controls color (both HSL and RGB variables) based on the current marker position
        /// </summary>
        private void ResetHSLRGB()
        {
            int red, green, blue;

            switch (m_eDrawStyle)
            {
            case eDrawStyle.Hue:
                m_hsl.S = (double)m_iMarker_X / (this.Width - 4);
                m_hsl.L = 1.0 - (double)m_iMarker_Y / (this.Height - 4);
                m_rgb   = AdobeColors.HSL_to_RGB(m_hsl);
                break;

            case eDrawStyle.Saturation:
                m_hsl.H = (double)m_iMarker_X / (this.Width - 4);
                m_hsl.L = 1.0 - (double)m_iMarker_Y / (this.Height - 4);
                m_rgb   = AdobeColors.HSL_to_RGB(m_hsl);
                break;

            case eDrawStyle.Brightness:
                m_hsl.H = (double)m_iMarker_X / (this.Width - 4);
                m_hsl.S = 1.0 - (double)m_iMarker_Y / (this.Height - 4);
                m_rgb   = AdobeColors.HSL_to_RGB(m_hsl);
                break;

            case eDrawStyle.Red:
                blue  = Round(255 * (double)m_iMarker_X / (this.Width - 4));
                green = Round(255 * (1.0 - (double)m_iMarker_Y / (this.Height - 4)));
                m_rgb = Color.FromArgb(m_rgb.R, green, blue);
                m_hsl = AdobeColors.RGB_to_HSL(m_rgb);
                break;

            case eDrawStyle.Green:
                blue  = Round(255 * (double)m_iMarker_X / (this.Width - 4));
                red   = Round(255 * (1.0 - (double)m_iMarker_Y / (this.Height - 4)));
                m_rgb = Color.FromArgb(red, m_rgb.G, blue);
                m_hsl = AdobeColors.RGB_to_HSL(m_rgb);
                break;

            case eDrawStyle.Blue:
                red   = Round(255 * (double)m_iMarker_X / (this.Width - 4));
                green = Round(255 * (1.0 - (double)m_iMarker_Y / (this.Height - 4)));
                m_rgb = Color.FromArgb(red, green, m_rgb.B);
                m_hsl = AdobeColors.RGB_to_HSL(m_rgb);
                break;
            }
        }
        /// <summary>
        /// Returns the graphed color at the x,y position on the control
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private AdobeColors.HSL GetColor(int x, int y)
        {
            AdobeColors.HSL _hsl = new AdobeColors.HSL();

            switch (m_eDrawStyle)
            {
            case eDrawStyle.Hue:
                _hsl.H = m_hsl.H;
                _hsl.S = (double)x / (this.Width - 4);
                _hsl.L = 1.0 - (double)y / (this.Height - 4);
                break;

            case eDrawStyle.Saturation:
                _hsl.S = m_hsl.S;
                _hsl.H = (double)x / (this.Width - 4);
                _hsl.L = 1.0 - (double)y / (this.Height - 4);
                break;

            case eDrawStyle.Brightness:
                _hsl.L = m_hsl.L;
                _hsl.H = (double)x / (this.Width - 4);
                _hsl.S = 1.0 - (double)y / (this.Height - 4);
                break;

            case eDrawStyle.Red:
                _hsl = AdobeColors.RGB_to_HSL(Color.FromArgb(m_rgb.R, Round(255 * (1.0 - (double)y / (this.Height - 4))), Round(255 * (double)x / (this.Width - 4))));
                break;

            case eDrawStyle.Green:
                _hsl = AdobeColors.RGB_to_HSL(Color.FromArgb(Round(255 * (1.0 - (double)y / (this.Height - 4))), m_rgb.G, Round(255 * (double)x / (this.Width - 4))));
                break;

            case eDrawStyle.Blue:
                _hsl = AdobeColors.RGB_to_HSL(Color.FromArgb(Round(255 * (double)x / (this.Width - 4)), Round(255 * (1.0 - (double)y / (this.Height - 4))), m_rgb.B));
                break;
            }

            return(_hsl);
        }
        /// <summary>
        /// Draws the content of the control filling in all color values with the provided Luminance or Brightness value.
        /// </summary>
        private void Draw_Style_Luminance()
        {
            Graphics g = this.CreateGraphics();

            AdobeColors.HSL hsl_start = new AdobeColors.HSL();
            AdobeColors.HSL hsl_end   = new AdobeColors.HSL();
            hsl_start.L = m_hsl.L;
            hsl_end.L   = m_hsl.L;
            hsl_start.S = 1.0;
            hsl_end.S   = 0.0;

            for (int i = 0; i < this.Width - 4; i++)                            //	For each vertical line in the control:
            {
                hsl_start.H = (double)i / (this.Width - 4);                     //	Calculate Hue at this line (Saturation and Luminance are constant)
                hsl_end.H   = hsl_start.H;

                LinearGradientBrush br = new LinearGradientBrush(new Rectangle(2, 2, 1, this.Height - 4), AdobeColors.HSL_to_RGB(hsl_start), AdobeColors.HSL_to_RGB(hsl_end), 90, false);
                g.FillRectangle(br, new Rectangle(i + 2, 2, 1, this.Height - 4));
            }
        }
        /// <summary>
        /// Redraws only the content over the marker
        /// </summary>
        private void ClearMarker()
        {
            Graphics g = this.CreateGraphics();

            //	Determine the area that needs to be redrawn
            int start_x, start_y, end_x, end_y;
            int red = 0; int green = 0; int blue = 0;

            AdobeColors.HSL hsl_start = new AdobeColors.HSL();
            AdobeColors.HSL hsl_end = new AdobeColors.HSL();

            //	Find the markers corners
            start_x = m_iMarker_X - 5;
            start_y = m_iMarker_Y - 5;
            end_x   = m_iMarker_X + 5;
            end_y   = m_iMarker_Y + 5;
            //	Adjust the area if part of it hangs outside the content area
            if (start_x < 0)
            {
                start_x = 0;
            }
            if (start_y < 0)
            {
                start_y = 0;
            }
            if (end_x > this.Width - 4)
            {
                end_x = this.Width - 4;
            }
            if (end_y > this.Height - 4)
            {
                end_y = this.Height - 4;
            }

            //	Redraw the content based on the current draw style:
            //	The code get's a little messy from here
            switch (m_eDrawStyle)
            {
            //		  S=0,S=1,S=2,S=3.....S=100
            //	L=100
            //	L=99
            //	L=98		Drawstyle
            //	L=97		   Hue
            //	...
            //	L=0
            case eDrawStyle.Hue:

                hsl_start.H = m_hsl.H;  hsl_end.H = m_hsl.H;                            //	Hue is constant
                hsl_start.S = (double)start_x / (this.Width - 4);                       //	Because we're drawing horizontal lines, s will not change
                hsl_end.S   = (double)end_x / (this.Width - 4);                         //	from line to line

                for (int i = start_y; i <= end_y; i++)                                  //	For each horizontal line:
                {
                    hsl_start.L = 1.0 - (double)i / (this.Height - 4);                  //	Brightness (L) WILL change for each horizontal
                    hsl_end.L   = hsl_start.L;                                          //	line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), AdobeColors.HSL_to_RGB(hsl_start), AdobeColors.HSL_to_RGB(hsl_end), 0, false);
                    g.FillRectangle(br, new Rectangle(start_x + 2, i + 2, end_x - start_x + 1, 1));
                }

                break;

            //		  H=0,H=1,H=2,H=3.....H=360
            //	L=100
            //	L=99
            //	L=98		Drawstyle
            //	L=97		Saturation
            //	...
            //	L=0
            case eDrawStyle.Saturation:

                hsl_start.S = m_hsl.S;  hsl_end.S = m_hsl.S;                                    //	Saturation is constant
                hsl_start.L = 1.0 - (double)start_y / (this.Height - 4);                        //	Because we're drawing vertical lines, L will
                hsl_end.L   = 1.0 - (double)end_y / (this.Height - 4);                          //	not change from line to line

                for (int i = start_x; i <= end_x; i++)                                          //	For each vertical line:
                {
                    hsl_start.H = (double)i / (this.Width - 4);                                 //	Hue (H) WILL change for each vertical
                    hsl_end.H   = hsl_start.H;                                                  //	line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(i + 2, start_y + 1, 1, end_y - start_y + 2), AdobeColors.HSL_to_RGB(hsl_start), AdobeColors.HSL_to_RGB(hsl_end), 90, false);
                    g.FillRectangle(br, new Rectangle(i + 2, start_y + 2, 1, end_y - start_y + 1));
                }
                break;

            //		  H=0,H=1,H=2,H=3.....H=360
            //	S=100
            //	S=99
            //	S=98		Drawstyle
            //	S=97		Brightness
            //	...
            //	S=0
            case eDrawStyle.Brightness:

                hsl_start.L = m_hsl.L;  hsl_end.L = m_hsl.L;                                    //	Luminance is constant
                hsl_start.S = 1.0 - (double)start_y / (this.Height - 4);                        //	Because we're drawing vertical lines, S will
                hsl_end.S   = 1.0 - (double)end_y / (this.Height - 4);                          //	not change from line to line

                for (int i = start_x; i <= end_x; i++)                                          //	For each vertical line:
                {
                    hsl_start.H = (double)i / (this.Width - 4);                                 //	Hue (H) WILL change for each vertical
                    hsl_end.H   = hsl_start.H;                                                  //	line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(i + 2, start_y + 1, 1, end_y - start_y + 2), AdobeColors.HSL_to_RGB(hsl_start), AdobeColors.HSL_to_RGB(hsl_end), 90, false);
                    g.FillRectangle(br, new Rectangle(i + 2, start_y + 2, 1, end_y - start_y + 1));
                }

                break;

            //		  B=0,B=1,B=2,B=3.....B=100
            //	G=100
            //	G=99
            //	G=98		Drawstyle
            //	G=97		   Red
            //	...
            //	G=0
            case eDrawStyle.Red:

                red = m_rgb.R;                                                                          //	Red is constant
                int start_b = Round(255 * (double)start_x / (this.Width - 4));                          //	Because we're drawing horizontal lines, B
                int end_b   = Round(255 * (double)end_x / (this.Width - 4));                            //	will not change from line to line

                for (int i = start_y; i <= end_y; i++)                                                  //	For each horizontal line:
                {
                    green = Round(255 - (255 * (double)i / (this.Height - 4)));                         //	green WILL change for each horizontal line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), Color.FromArgb(red, green, start_b), Color.FromArgb(red, green, end_b), 0, false);
                    g.FillRectangle(br, new Rectangle(start_x + 2, i + 2, end_x - start_x + 1, 1));
                }

                break;

            //		  B=0,B=1,B=2,B=3.....B=100
            //	R=100
            //	R=99
            //	R=98		Drawstyle
            //	R=97		  Green
            //	...
            //	R=0
            case eDrawStyle.Green:

                green = m_rgb.G;;                                                                       //	Green is constant
                int start_b2 = Round(255 * (double)start_x / (this.Width - 4));                         //	Because we're drawing horizontal lines, B
                int end_b2   = Round(255 * (double)end_x / (this.Width - 4));                           //	will not change from line to line

                for (int i = start_y; i <= end_y; i++)                                                  //	For each horizontal line:
                {
                    red = Round(255 - (255 * (double)i / (this.Height - 4)));                           //	red WILL change for each horizontal line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), Color.FromArgb(red, green, start_b2), Color.FromArgb(red, green, end_b2), 0, false);
                    g.FillRectangle(br, new Rectangle(start_x + 2, i + 2, end_x - start_x + 1, 1));
                }

                break;

            //		  R=0,R=1,R=2,R=3.....R=100
            //	G=100
            //	G=99
            //	G=98		Drawstyle
            //	G=97		   Blue
            //	...
            //	G=0
            case eDrawStyle.Blue:

                blue = m_rgb.B;;                                                                        //	Blue is constant
                int start_r = Round(255 * (double)start_x / (this.Width - 4));                          //	Because we're drawing horizontal lines, R
                int end_r   = Round(255 * (double)end_x / (this.Width - 4));                            //	will not change from line to line

                for (int i = start_y; i <= end_y; i++)                                                  //	For each horizontal line:
                {
                    green = Round(255 - (255 * (double)i / (this.Height - 4)));                         //	green WILL change for each horizontal line drawn

                    LinearGradientBrush br = new LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), Color.FromArgb(start_r, green, blue), Color.FromArgb(end_r, green, blue), 0, false);
                    g.FillRectangle(br, new Rectangle(start_x + 2, i + 2, end_x - start_x + 1, 1));
                }

                break;
            }
        }