public ColorPicker(Color starting_color)
        {
            InitializeComponent();

            m_rgb = starting_color;
            m_hsl = MyColors.RGB_to_HSL(m_rgb);
            m_cmyk = MyColors.RGB_to_CMYK(m_rgb);

            m_txt_Red.Text = m_rgb.R.ToString();
            m_txt_Green.Text = m_rgb.G.ToString();
            m_txt_Blue.Text = m_rgb.B.ToString();
            this.textAlpha.Text = m_rgb.A.ToString();
            this.trackBar.Value = m_rgb.A;

            m_txt_Red.Update();
            m_txt_Green.Update();
            m_txt_Blue.Update();
            this.textAlpha.Update();
            this.trackBar.Update();

            m_ctrl_BigBox.HSL = m_hsl;
            m_ctrl_ThinBox.HSL = m_hsl;

            this.m_pbx_BlankBox.Controls.Add(this.m_lbl_Primary_Color);
            this.m_pbx_BlankBox.Controls.Add(this.m_lbl_Secondary_Color);

            m_lbl_Primary_Color.BackColor = starting_color;
            m_lbl_Secondary_Color.BackColor = starting_color;

            this.WriteHexData(m_rgb);
            this.m_pbx_BlankBox.BackgroundImage = My.Draw.BuildGrid(5, m_pbx_BlankBox);

            this.textTBC.Visible = false;
            this.labelTBC.Visible = false;

            // Localizzazione del testo
            /*
            this.m_lbl_SelectColor.Text =	"Seleziona il colore:";
            this.Text =	"Selezione del colore";
            this.labelAlpha.Text = "Alpha:";
            this.labelTBC.Text = "Codice:";
            this.m_cmd_OK.Text = "OK";
            this.m_cmd_Cancel.Text = "Annulla";
            this.buttonDefault.Text = "Default";*/
        }
        public ctrl2DColorBox()
        {
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();

            //	Initialize Colors
            m_hsl = new MyColors.HSL();
            m_hsl.H = 1.0;
            m_hsl.S = 1.0;
            m_hsl.L = 1.0;
            m_rgb = MyColors.HSL_to_RGB(m_hsl);
            m_eDrawStyle = eDrawStyle.Hue;
        }
        private void m_txt_Red_Leave(object sender, System.EventArgs e)
        {
            string text = m_txt_Red.Text;
            bool has_illegal_chars = false;

            if (text.Length <= 0)
                has_illegal_chars = true;
            else
                foreach (char letter in text)
                {
                    if (!char.IsNumber(letter))
                    {
                        has_illegal_chars = true;
                        break;
                    }
                }

            if (has_illegal_chars)
            {
                My.Box.Warning("Non è un colore RGB");
                UpdateTextBoxes();
                return;
            }

            int red = int.Parse(text);

            if (red < 0)
            {
                My.Box.Warning("Non è un colore RGB");
                m_rgb = Color.FromArgb(0, m_rgb.G, m_rgb.B);
            }
            else if (red > 255)
            {
                My.Box.Warning("Non è un colore RGB");
                m_rgb = Color.FromArgb(255, m_rgb.G, m_rgb.B);
            }
            else
            {
                m_rgb = Color.FromArgb(red, m_rgb.G, m_rgb.B);
            }

            m_hsl = MyColors.RGB_to_HSL(m_rgb);
            m_cmyk = MyColors.RGB_to_CMYK(m_rgb);
            m_ctrl_BigBox.HSL = m_hsl;
            m_ctrl_ThinBox.HSL = m_hsl;
            m_lbl_Primary_Color.BackColor = m_rgb;

            UpdateTextBoxes();
        }
        private void m_txt_Hex_Leave(object sender, System.EventArgs e)
        {
            string text = m_txt_Hex.Text.ToUpper();
            bool has_illegal_chars = false;

            if (text.Length <= 0)
                has_illegal_chars = true;
            foreach (char letter in text)
            {
                if (!char.IsNumber(letter))
                {
                    if (letter >= 'A' && letter <= 'F')
                        continue;
                    has_illegal_chars = true;
                    break;
                }
            }

            if (has_illegal_chars)
            {
                My.Box.Warning("Non è un numero esadecimale");
                WriteHexData(m_rgb);
                return;
            }

            m_rgb = ParseHexData(text);
            m_rgb = ToTransparent(m_rgb);
            m_hsl = MyColors.RGB_to_HSL(m_rgb);
            m_cmyk = MyColors.RGB_to_CMYK(m_rgb);

            m_ctrl_BigBox.HSL = m_hsl;
            m_ctrl_ThinBox.HSL = m_hsl;
            m_lbl_Primary_Color.BackColor = m_rgb;

            UpdateTextBoxes();
        }
        private void m_lbl_Secondary_Color_Click(object sender, System.EventArgs e)
        {
            m_rgb = m_lbl_Secondary_Color.BackColor;
            m_hsl = MyColors.RGB_to_HSL(m_rgb);

            m_ctrl_BigBox.HSL = m_hsl;
            m_ctrl_ThinBox.HSL = m_hsl;

            m_lbl_Primary_Color.BackColor = m_rgb;
            m_lbl_Primary_Color.Update();

            m_cmyk = MyColors.RGB_to_CMYK(m_rgb);

            m_txt_Red.Text = m_rgb.R.ToString();
            m_txt_Green.Text = m_rgb.G.ToString();
            m_txt_Blue.Text = m_rgb.B.ToString();
            this.textAlpha.Text = m_rgb.A.ToString();
            this.trackBar.Value = (int)m_rgb.A;

            m_txt_Red.Update();
            m_txt_Green.Update();
            m_txt_Blue.Update();
            this.textAlpha.Update();
            this.trackBar.Update();
        }
        private void m_ctrl_ThinBox_Scroll(object sender, System.EventArgs e)
        {
            m_hsl = m_ctrl_ThinBox.HSL;
            m_rgb = MyColors.HSL_to_RGB(m_hsl);
            m_rgb = ToTransparent(m_rgb);
            m_cmyk = MyColors.RGB_to_CMYK(m_rgb);

            m_txt_Red.Text = m_rgb.R.ToString();
            m_txt_Green.Text = m_rgb.G.ToString();
            m_txt_Blue.Text = m_rgb.B.ToString();

            m_txt_Red.Update();
            m_txt_Green.Update();
            m_txt_Blue.Update();

            m_ctrl_BigBox.HSL = m_hsl;

            m_lbl_Primary_Color.BackColor = m_rgb;
            m_lbl_Primary_Color.Update();

            WriteHexData(m_rgb);
        }
 /// <summary>
 /// Resets the controls color (both HSL and RGB variables) based on the current slider position
 /// </summary>
 private void ResetHSLRGB()
 {
     switch (m_eDrawStyle)
     {
         case eDrawStyle.Hue:
             m_hsl.H = 1.0 - (double)m_iMarker_Start_Y / (this.Height - 9);
             m_rgb = MyColors.HSL_to_RGB(m_hsl);
             break;
         case eDrawStyle.Saturation:
             m_hsl.S = 1.0 - (double)m_iMarker_Start_Y / (this.Height - 9);
             m_rgb = MyColors.HSL_to_RGB(m_hsl);
             break;
         case eDrawStyle.Brightness:
             m_hsl.L = 1.0 - (double)m_iMarker_Start_Y / (this.Height - 9);
             m_rgb = MyColors.HSL_to_RGB(m_hsl);
             break;
         case eDrawStyle.Red:
             m_rgb = Color.FromArgb(255 - Round(255 * (double)m_iMarker_Start_Y / (this.Height - 9)), m_rgb.G, m_rgb.B);
             m_hsl = MyColors.RGB_to_HSL(m_rgb);
             break;
         case eDrawStyle.Green:
             m_rgb = Color.FromArgb(m_rgb.R, 255 - Round(255 * (double)m_iMarker_Start_Y / (this.Height - 9)), m_rgb.B);
             m_hsl = MyColors.RGB_to_HSL(m_rgb);
             break;
         case eDrawStyle.Blue:
             m_rgb = Color.FromArgb(m_rgb.R, m_rgb.G, 255 - Round(255 * (double)m_iMarker_Start_Y / (this.Height - 9)));
             m_hsl = MyColors.RGB_to_HSL(m_rgb);
             break;
     }
 }
        //    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();

            MyColors.HSL _hsl = new MyColors.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(MyColors.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>
        /// Fills in the content of the control showing all values of Saturation (0 to 100%) for the given
        /// Hue and Luminance.
        /// </summary>
        private void Draw_Style_Saturation()
        {
            Graphics g = this.CreateGraphics();

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

            for (int i = 0; i < this.Height - 8; i++) //	i represents the current line of pixels we want to draw horizontally
            {
                _hsl.S = 1.0 - (double)i / (this.Height - 8);			//	S (Saturation) is based on the current vertical position
                Pen pen = new Pen(MyColors.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 = MyColors.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 = MyColors.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 = MyColors.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 = System.Drawing.Color.FromArgb(m_rgb.R, green, blue);
                    m_hsl = MyColors.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 = System.Drawing.Color.FromArgb(red, m_rgb.G, blue);
                    m_hsl = MyColors.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 = System.Drawing.Color.FromArgb(red, green, m_rgb.B);
                    m_hsl = MyColors.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 MyColors.HSL GetColor(int x, int y)
        {
            MyColors.HSL _hsl = new MyColors.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 = MyColors.RGB_to_HSL(System.Drawing.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 = MyColors.RGB_to_HSL(System.Drawing.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 = MyColors.RGB_to_HSL(System.Drawing.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 Saturation value.
        /// </summary>
        private void Draw_Style_Saturation()
        {
            Graphics g = this.CreateGraphics();

            MyColors.HSL hsl_start = new MyColors.HSL();
            MyColors.HSL hsl_end = new MyColors.HSL();
            hsl_start.S = m_hsl.S;
            hsl_end.S = m_hsl.S;
            hsl_start.L = 1.0;
            hsl_end.L = 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;

                System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(
                    new Rectangle(2, 2, 1, this.Height - 4), MyColors.HSL_to_RGB(hsl_start), MyColors.HSL_to_RGB(hsl_end), 90, false);
                g.FillRectangle(br, new Rectangle(i + 2, 2, 1, this.Height - 4));
            }
        }
        /// <summary>
        /// Draws the content of the control filling in all color values with the provided Hue value.
        /// </summary>
        private void Draw_Style_Hue()
        {
            Graphics g = this.CreateGraphics();

            MyColors.HSL hsl_start = new MyColors.HSL();
            MyColors.HSL hsl_end = new MyColors.HSL();
            hsl_start.H = m_hsl.H;
            hsl_end.H = m_hsl.H;
            hsl_start.S = 0.0;
            hsl_end.S = 1.0;

            for (int i = 0; i < this.Height - 4; i++)				//	For each horizontal line in the control:
            {
                hsl_start.L = 1.0 - (double)i / (this.Height - 4);	//	Calculate luminance at this line (Hue and Saturation are constant)
                hsl_end.L = hsl_start.L;

                System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(
                    new Rectangle(2, 2, this.Width - 4, 1), MyColors.HSL_to_RGB(hsl_start), MyColors.HSL_to_RGB(hsl_end), 0, false);
                g.FillRectangle(br, new Rectangle(2, i + 2, this.Width - 4, 1));
            }
        }
        /// <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;
            MyColors.HSL hsl_start = new MyColors.HSL();
            MyColors.HSL hsl_end = new MyColors.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), MyColors.HSL_to_RGB(hsl_start), MyColors.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(new Rectangle(i + 2, start_y + 1, 1, end_y - start_y + 2), MyColors.HSL_to_RGB(hsl_start), MyColors.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(new Rectangle(i + 2, start_y + 1, 1, end_y - start_y + 2), MyColors.HSL_to_RGB(hsl_start), MyColors.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1), System.Drawing.Color.FromArgb(red, green, start_b), System.Drawing.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(
                            new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1),
                            System.Drawing.Color.FromArgb(red, green, start_b2),
                            System.Drawing.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

                        System.Drawing.Drawing2D.LinearGradientBrush br = new System.Drawing.Drawing2D.LinearGradientBrush(
                            new Rectangle(start_x + 1, i + 2, end_x - start_x + 1, 1),
                            System.Drawing.Color.FromArgb(start_r, green, blue),
                            System.Drawing.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;
            }
        }