Foxtheme

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Drawing;
    using System.Drawing.Drawing2D;

    /// <summary>
    /// Created by DoggyCollin
    /// HF link: http://www.hackforums.net/member.php?action=profile&uid=1278211
    /// </summary>

    internal static class FoxSettings
    {
        public static Pen BorderColor = new Pen(Color.FromArgb(49, 49, 49));
        public static SolidBrush TextColor = new SolidBrush(Color.FromArgb(249, 249, 249));
        public static SolidBrush TextColorDark = new SolidBrush(Color.FromArgb(66, 66, 66));
        public static SolidBrush FillheaderColor = new SolidBrush(Color.FromArgb(237, 237, 237));
        public static SolidBrush FillbodyColor = new SolidBrush(Color.FromArgb(250, 250, 250));

        public static SolidBrush UpColor = new SolidBrush(Color.FromArgb(255, 136, 83)); // Orange(255, 136, 83), Green(116, 214, 36), Blue(90, 160, 220), Red(232, 67, 67)
        public static SolidBrush DownColor = new SolidBrush(Color.FromArgb(UpColor.Color.R - 33, UpColor.Color.G - 33, UpColor.Color.B - 33));

        public static Font TextFont = new Font("Verdana", 8.0F);
    }

    internal class FoxTheme : Control
    {
        /// <summary>
        /// Gets or sets the visibility of the icon copied from the parent control.
        /// </summary>
        public bool ShowIcon { get { return _showIcon; } set { _showIcon = value; Invalidate(); } }
        private bool _showIcon;

        private Graphics G;

        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillheaderColor;
        private SolidBrush fillbodyColor;

        public FoxTheme()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.ResizeRedraw, true);
            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillheaderColor = FoxSettings.FillheaderColor;
            fillbodyColor = FoxSettings.FillbodyColor;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            Dock = DockStyle.Fill;
            if (Parent is Form)
            {
                Form tempWith1 = (Form)Parent;
                tempWith1.FormBorderStyle = 0;
                tempWith1.TransparencyKey = Color.Fuchsia;
                tempWith1.BackColor = fillheaderColor.Color;
            }
            base.OnHandleCreated(e);
        }

        protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
        {
            if (new Rectangle(Parent.Location.X, Parent.Location.Y, Width, 22).IntersectsWith(new Rectangle(MousePosition.X, MousePosition.Y, 1, 1)))
            {
                Capture = false;
                Message M = Message.Create(Parent.Handle, 161, new IntPtr(2), IntPtr.Zero);
                DefWndProc(ref M);
            }
            base.OnMouseDown(e);
        }

        protected override void OnPaintBackground(PaintEventArgs pevent) {  }

        protected override void OnPaint(PaintEventArgs e)
        {
            var B = new Bitmap(Width, Height);
            using (var G = Graphics.FromImage(B))
            {
                G.DrawPath(new Pen(fillheaderColor.Color), RoundedRectangle.Create(0, 0, Width, Height, 4));
                G.FillPath(fillheaderColor, RoundedRectangle.Create(0, 0, Width, Height, 4));

                G.DrawString(Text, Font, new SolidBrush(Color.FromArgb(66, 66, 66)), new Point(5, 5));

                G.DrawPath(new Pen(fillbodyColor.Color), RoundedRectangle.Create(6, 22, Width - 13, Height - 28, 4));
                G.FillPath(fillbodyColor, RoundedRectangle.Create(6, 22, Width - 13, Height - 28, 4));

                G.DrawPath(new Pen(Color.LightGray), RoundedRectangle.Create(0, 0, Width - 1, Height - 1, 4));

                G.FillRectangle(new SolidBrush(Color.Fuchsia), new Rectangle(0, 0, 2, 2));
                G.FillRectangle(new SolidBrush(Color.Fuchsia), new Rectangle(Width - 2, 0, 2, 2));
                G.FillRectangle(new SolidBrush(Color.Fuchsia), new Rectangle(Width - 2, Height - 2, 2, 2));
                G.FillRectangle(new SolidBrush(Color.Fuchsia), new Rectangle(0, Height - 2, 2, 2));

                B.SetPixel(1, 1, fillheaderColor.Color);
                B.SetPixel(Width - 2, 1, fillheaderColor.Color);
                B.SetPixel(Width - 2, Height - 2, fillheaderColor.Color);
                B.SetPixel(1, Height - 2, fillheaderColor.Color);

                e.Graphics.DrawImage(B, 0, 0);
            }

            B.Dispose();
        }
    }

    internal class FoxButton : Control
    {
        private Graphics G;
        private bool isMouseDown;

        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillColor;
        private SolidBrush downColor;

        private StringFormat stringformat;
        private Font textFont;

        public FoxButton()
        {
            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillColor = FoxSettings.UpColor;
            downColor = FoxSettings.DownColor;

            stringformat = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center };
            textFont = FoxSettings.TextFont;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            isMouseDown = true;
            Invalidate();
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            isMouseDown = false;
            Invalidate();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            G = e.Graphics;
            G.Clear(BackColor);
            G.SmoothingMode = SmoothingMode.HighQuality;

            SolidBrush currentBrush;

            if (isMouseDown)
                currentBrush = downColor;
            else
                currentBrush = fillColor;

            LinearGradientBrush linGrBrush = GraphicsHelper.CreateGradient(Width, Height, currentBrush);

            G.DrawPath(new Pen(currentBrush), RoundedRectangle.Create(0, 0, Width, Height, 4));
            G.FillPath(linGrBrush, RoundedRectangle.Create(0, 0, Width, Height, 4));
            G.DrawString(Text, textFont, textColor, new Point(Width / 2, Height / 2), stringformat);
        }
    }

    internal class FoxSystemButton : Control
    {
        private Graphics G;
        private bool isMouseDown;

        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillColor;
        private SolidBrush downColor;
        public SolidBrush upColor;

        private StringFormat stringformat;
        private Font textFont;

        public enum BType
        {
            Close,
            Minimize
        }

        public BType ButtonType { get; set; }

        public FoxSystemButton()
        {
            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillColor = FoxSettings.FillheaderColor;
            downColor = FoxSettings.DownColor;
            upColor = FoxSettings.UpColor;

            stringformat = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center };
            textFont = FoxSettings.TextFont;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
            ButtonType = BType.Close;
            Size = new Size(14, 14);
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            isMouseDown = true;
            Invalidate();
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            isMouseDown = false;
            Invalidate();

            var form = FindForm();

            if (this.ClientRectangle.Contains(e.Location))
            {
                if (ButtonType == BType.Close)
                    form.Close();
                else if (ButtonType == BType.Minimize)
                    form.WindowState = FormWindowState.Minimized;
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            G = e.Graphics;
            G.Clear(BackColor);
            G.SmoothingMode = SmoothingMode.HighQuality;

            SolidBrush currentBrush;

            if (isMouseDown)
                currentBrush = downColor;
            else
                currentBrush = upColor;

            G.DrawRectangle(new Pen(fillColor.Color), new Rectangle(0, 0, 14, 14));
            G.FillRectangle(fillColor, new Rectangle(0, 0, 14, 14));

            if (ButtonType == BType.Close)
            {
                G.DrawLine(new Pen(currentBrush, 1.6f), 2, 2, 10, 10);
                G.DrawLine(new Pen(currentBrush, 1.6f), 10, 2, 2, 10);
            }
            else if (ButtonType == BType.Minimize)
            {
                G.DrawLine(new Pen(currentBrush, 2f), 2, 10, 10, 10);
            }
        }

        public static void DrawRoundedRectangle(Graphics g, Rectangle r, int d, Pen p)
        {
            System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();

            gp.AddArc(r.X, r.Y, d, d, 180, 90);
            gp.AddArc(r.X + r.Width - d, r.Y, d, d, 270, 90);
            gp.AddArc(r.X + r.Width - d, r.Y + r.Height - d, d, d, 0, 90);
            gp.AddArc(r.X, r.Y + r.Height - d, d, d, 90, 90);
            gp.AddLine(r.X, r.Y + r.Height - d, r.X, r.Y + d / 2);

            g.DrawPath(p, gp);
        }
    }

    internal class FoxProgressBar : Control
    {
        /// <summary>
        /// Value in percentage.
        /// </summary>
        public float Value { get { return _value; } set { _value = value; Invalidate(); } }
        private float _value;

        /// <summary>
        /// Sets or gets the visibility setting for the percentage value.
        /// </summary>
        public bool ShowPercentage { get; set; }

        private Graphics G;

        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillColor;
        private SolidBrush bodyColor;
        private SolidBrush downColor;
        private SolidBrush upColor;

        private StringFormat stringformat;
        private Font textFont;

        public FoxProgressBar()
        {
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillColor = FoxSettings.FillheaderColor;
            bodyColor = FoxSettings.FillbodyColor;
            downColor = FoxSettings.DownColor;
            upColor = FoxSettings.UpColor;

            stringformat = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center };
            textFont = FoxSettings.TextFont;
            ShowPercentage = true;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            G = e.Graphics;
            G.Clear(bodyColor.Color);
            G.SmoothingMode = SmoothingMode.HighQuality;

            float percent = ((float)Width / 100) * Value;

            LinearGradientBrush linGrBrush = GraphicsHelper.CreateGradient(Width, Height, upColor);

            G.FillPath(fillColor, RoundedRectangle.Create(0, 0, Width - 1, Height - 1, 4));

            if ((int)percent <= 0)
                G.FillPath(fillColor, RoundedRectangle.Create(0, 1, (int)percent, Height - 2, 4));
            else
                G.FillPath(linGrBrush, RoundedRectangle.Create(0, 1, (int)percent, Height - 2, 4));

            G.DrawPath(new Pen(Color.LightGray), RoundedRectangle.Create(0, 0, Width - 1, Height - 1, 4));


            var myColor = Value > 50 ? textColor.Color : Color.FromArgb(textColor.Color.ToArgb() ^ 0xffffff);
            if (ShowPercentage)
                G.DrawString(string.Format("{0}%", Value), textFont, new SolidBrush(myColor), new Point((Width + 2) / 2, (Height + 2) / 2), stringformat);
        }
    }

    internal class FoxTabControl : TabControl
    {
        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillColor;
        private SolidBrush downColor;
        private SolidBrush upColor;
        private SolidBrush fillbodyColor;

        private Font textFont;

        public FoxTabControl()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
            DoubleBuffered = true;
            SizeMode = TabSizeMode.Fixed;

            this.TabItemWidth = 120;
            this.TabItemHeight = 30;
            this.Alignment = TabAlignment.Left;
            ItemSize = new Size(TabItemHeight, TabItemWidth);

            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillColor = FoxSettings.FillheaderColor;
            downColor = FoxSettings.DownColor;
            upColor = FoxSettings.UpColor;
            fillbodyColor = FoxSettings.FillbodyColor;

            textFont = FoxSettings.TextFont;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Bitmap B = new Bitmap(Width, Height);

            if (Alignment == TabAlignment.Top)
                DrawTopTabControl(Graphics.FromImage(B));
            else if (Alignment == TabAlignment.Right)
                DrawRightTabControl(Graphics.FromImage(B));
            else if (Alignment == TabAlignment.Bottom)
                DrawBottomTabControl(Graphics.FromImage(B));
            else if (Alignment == TabAlignment.Left)
                DrawLeftTabControl(Graphics.FromImage(B));

            e.Graphics.DrawImage((Image)B.Clone(), 0, 4);
            B.Dispose();
        }

        private void DrawTopTabControl(Graphics G)
        {
            G.Clear(fillbodyColor.Color);

            for (int i = 0; i <= TabCount - 1; i++)
            {
                Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1));

                G.FillRectangle(textColor, new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(GetTabRect(i).Size.Width, GetTabRect(i).Size.Height)));
                if (i == SelectedIndex)
                {
                    G.FillPath(upColor, RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, GetTabRect(i).Size.Height - 5), new Size(GetTabRect(i).Size.Width, 5)), 2));
                    G.DrawPath(new Pen(upColor.Color), RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, GetTabRect(i).Size.Height - 5), new Size(GetTabRect(i).Size.Width, 3)), 2));
                }

                G.DrawString(TabPages[i].Text, Font, FoxSettings.TextColorDark, new Rectangle(x2.Location.X, x2.Location.Y, x2.Width, x2.Height), new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Center
                });
            }

            G.Dispose();
        }

        private void DrawRightTabControl(Graphics G)
        {
            G.Clear(fillbodyColor.Color);

            for (int i = 0; i <= TabCount - 1; i++)
            {
                Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1));

                G.FillRectangle(textColor, new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(GetTabRect(i).Size.Width, GetTabRect(i).Size.Height)));
                if (i == SelectedIndex)
                {
                    G.FillPath(upColor, RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(5, GetTabRect(i).Size.Height)), 2));
                    G.DrawPath(new Pen(upColor.Color), RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(3, GetTabRect(i).Size.Height)), 2));
                }

                G.DrawString(TabPages[i].Text, Font, new SolidBrush(Color.FromArgb(66, 66, 66)), new Rectangle(x2.Location.X + 10, x2.Location.Y, x2.Width, x2.Height), new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Near
                });
            }

            G.Dispose();
        }

        private void DrawBottomTabControl(Graphics G)
        {
            G.Clear(fillbodyColor.Color);

            for (int i = 0; i <= TabCount - 1; i++)
            {
                Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1));

                G.FillRectangle(textColor, new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(GetTabRect(i).Size.Width, GetTabRect(i).Size.Height)));
                if (i == SelectedIndex)
                {
                    G.FillPath(upColor, RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, x2.Location.Y - 5), new Size(GetTabRect(i).Size.Width, 5)), 2));
                    G.DrawPath(new Pen(upColor.Color), RoundedRectangle.Create(new Rectangle(new Point(x2.Location.X, x2.Location.Y - 5), new Size(GetTabRect(i).Size.Width, 3)), 2));
                }

                G.DrawString(TabPages[i].Text, Font, new SolidBrush(Color.FromArgb(66, 66, 66)), new Rectangle(x2.Location.X, x2.Location.Y, x2.Width, x2.Height), new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Center
                });
            }

            G.Dispose();
        }

        private void DrawLeftTabControl(Graphics G)
        {
            G.Clear(fillbodyColor.Color);

            for (int i = 0; i <= TabCount - 1; i++)
            {
                Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1));

                G.FillRectangle(textColor, new Rectangle(new Point(x2.Location.X, x2.Location.Y), new Size(GetTabRect(i).Size.Width, GetTabRect(i).Size.Height)));
                if (i == SelectedIndex)
                {
                    G.FillPath(upColor, RoundedRectangle.Create(new Rectangle(new Point(GetTabRect(i).Size.Width - 5, x2.Location.Y), new Size(5, GetTabRect(i).Size.Height)), 2));
                    G.DrawPath(new Pen(upColor.Color), RoundedRectangle.Create(new Rectangle(new Point(GetTabRect(i).Size.Width - 5, x2.Location.Y), new Size(3, GetTabRect(i).Size.Height)), 2));
                }

                G.DrawString(TabPages[i].Text, Font, new SolidBrush(Color.FromArgb(66, 66, 66)), new Rectangle(x2.Location.X, x2.Location.Y, x2.Width - 20, x2.Height), new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Far
                });
            }

            G.Dispose();
        }

        private int tabItemWidth;
        public int TabItemWidth { get { return tabItemWidth; } set { tabItemWidth = value; RefreshItemSize(); } }

        private int tabItemHeight;
        public int TabItemHeight { get { return tabItemHeight; } set { tabItemHeight = value; RefreshItemSize(); } }

        public void RefreshItemSize()
        {
            if (Alignment == TabAlignment.Top || Alignment == TabAlignment.Bottom)
                ItemSize = new Size(TabItemWidth, TabItemHeight);
            else if (Alignment == TabAlignment.Left || Alignment == TabAlignment.Right)
                ItemSize = new Size(TabItemHeight, TabItemWidth);

            Invalidate();
        }

        public override Color BackColor
        {
            get
            {
                return fillbodyColor.Color;
            }
            set
            {
                base.BackColor = value;
            }
        }

        public TabAlignment TabItemAlignment
        {
            get
            {
                return base.Alignment;
            }
            set
            {
                base.Alignment = value;
                RefreshItemSize();
            }
        }

        protected override void OnControlAdded(ControlEventArgs e)
        {
            e.Control.BackColor = fillbodyColor.Color;
            e.Control.Invalidate();
        }

    }

    internal class FoxCheckBox : Control
    {
        public bool Checked { get; set; }
        public CheckStyleType CheckStyle { get; set; }

        private Graphics G;

        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillColor;
        private SolidBrush downColor;
        private SolidBrush upColor;

        private StringFormat stringformat;
        private Font textFont;

        public FoxCheckBox()
        {
            borderColor = new Pen(Color.LightGray);
            textColor = FoxSettings.TextColorDark;
            fillColor = FoxSettings.FillheaderColor;
            downColor = FoxSettings.DownColor;
            upColor = FoxSettings.UpColor;

            stringformat = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center };
            textFont = FoxSettings.TextFont;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
            Checked = true;
            CheckStyle = CheckStyleType.Square;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            G = e.Graphics;

            switch (CheckStyle)
            {
                case CheckStyleType.Square:
                    G.DrawRectangle(borderColor, new Rectangle(0, 0, 12, 12));
                    G.DrawString(Text, textFont, textColor, 14, 0);

                    if (Checked)
                        G.FillRectangle(GraphicsHelper.CreateGradient(2, 9, upColor), new Rectangle(2, 2, 9, 9));
                    break;
                case CheckStyleType.Round:
                    G.DrawEllipse(borderColor, new Rectangle(0, 0, 13, 13));
                    G.DrawString(Text, textFont, textColor, 14, 0);

                    if (Checked)
                        G.FillEllipse(GraphicsHelper.CreateGradient(2, 9, upColor), new Rectangle(2, 2, 9, 9));
                    break;
                case CheckStyleType.Checkmark:
                    G.DrawRectangle(borderColor, new Rectangle(0, 0, 12, 12));
                    G.DrawString(Text, textFont, textColor, 14, 0);

                    if (Checked)
                    {
                        G.DrawString("\u221A", new Font("serif", 6, FontStyle.Bold), upColor, 3, 3);
                        //G.DrawLine(new Pen(downColor.Color, 2), 3, 5, 7, 9);
                        //G.DrawLine(new Pen(downColor.Color, 2), 6, 9, 9, 3);
                    }
                    break;
                default:
                    break;
            }
        }

        protected override void OnMouseClick(MouseEventArgs e)
        {
            Checked = !Checked;
            Invalidate();
        }

        public enum CheckStyleType
        {
            Square = 0,
            Round = 1,
            Checkmark = 2
        }
    }

    internal class FoxChartControl : Control
    {
        private Pen borderColor;
        private SolidBrush textColor;
        private SolidBrush fillheaderColor;
        private SolidBrush fillbodyColor;

        private Color colorStripes;
        private Color colorValues;
        private Color colorText;

        public float[] Values { get; set; }

        public float? ValueMin { get; set; }
        public float? ValueMax { get; set; }
        public float ValueStripes { get; set; }

        public float SizeStripes { get; set; }
        public float SizeValues { get; set; }

        public Font FontText { get; set; }

        public FoxChartControl()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.ResizeRedraw, true);
            borderColor = FoxSettings.BorderColor;
            textColor = FoxSettings.TextColor;
            fillheaderColor = FoxSettings.FillheaderColor;
            fillbodyColor = FoxSettings.FillbodyColor;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
            BackColor = fillbodyColor.Color;

            Values = new float[] { };

            ValueMax = null;
            ValueMin = null;
            ValueStripes = 10;

            SizeStripes = 1;
            SizeValues = 4;

            colorStripes = Color.LightGray;
            colorValues = FoxSettings.UpColor.Color;
            colorText = Color.Black;

            FontText = FoxSettings.TextFont;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            var G = e.Graphics;

            float max = ValueMax ?? (Values.Count() > 0 ? Values.Max() : 0);
            float min = ValueMin ?? (Values.Count() > 0 ? Values.Min() : 0);

            float averagegeCount = (max - min) / ValueStripes;
            float currentCount = max;

            G.SmoothingMode = SmoothingMode.HighQuality;

            float startWidthPosition = ValueMax == null
                ? GraphicsHelper.GetTextWidthInPixels(Values.Select(a => a.ToString()).OrderByDescending(a => a.Length).FirstOrDefault(), FontText)
                : GraphicsHelper.GetTextWidthInPixels(ValueMax.ToString(), FontText);

            float chartHeight = Height - 17;
            float itemHeight = 10;

            G.FillPath(fillheaderColor, RoundedRectangle.Create(0, 0, Width - 1, Height - 1, 4));

            for (int i = 0; i <= ValueStripes; i++)
            {
                G.DrawLine(new Pen(ColorStripes, SizeStripes), startWidthPosition, itemHeight, Width, itemHeight);
                G.DrawString((Math.Floor(currentCount)).ToString(), FontText, new SolidBrush(ColorText), 0, itemHeight - 7);
                itemHeight += chartHeight / ValueStripes;
                currentCount -= averagegeCount;
            }

            float lastItemHeight = (chartHeight - (chartHeight / (max - min) * (Values.FirstOrDefault() - min))) + 10;
            float lastItemWidth = startWidthPosition;
            float itemWidth = startWidthPosition;

            foreach (var value in Values)
            {
                var valueMin = value - min;

                var item = chartHeight - (chartHeight / (max - min) * valueMin);
                item = item == chartHeight ? chartHeight + 10 : item + 10;

                var currentBrush = FoxSettings.UpColor;
                G.DrawLine(new Pen(currentBrush.Color, SizeValues), lastItemWidth, lastItemHeight, itemWidth, item);
                G.FillEllipse(currentBrush, itemWidth - (SizeValues / 2), item - (SizeValues / 2), SizeValues, SizeValues);

                lastItemHeight = item;
                lastItemWidth = itemWidth;
                itemWidth += Width / Values.Count();
            }
        }

        public Color ColorStripes
        {
            get
            {
                return this.colorStripes;
            }
            set
            {
                this.colorStripes = value;
            }
        }

        public Color ColorValues
        {
            get
            {
                return this.colorValues;
            }
            set
            {
                this.colorValues = value;
            }
        }

        public Color ColorText
        {
            get
            {
                return this.colorText;
            }
            set
            {
                this.colorText = value;
            }
        }
    }

    internal class FoxLabel : Control
    {
        private SolidBrush textColor;
        private Font textFont;

        public FoxLabel()
        {
            textColor = FoxSettings.TextColorDark;
            textFont = FoxSettings.TextFont;

            //Set defaults
            Font = FoxSettings.TextFont;
            ForeColor = textColor.Color;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            var G = e.Graphics;
            G.DrawString(Text, textFont, textColor, 0, 0);
        }
    }


    public abstract class RoundedRectangle
    {
        public enum RectangleCorners
        {
            None = 0, TopLeft = 1, TopRight = 2, BottomLeft = 4, BottomRight = 8,
            All = TopLeft | TopRight | BottomLeft | BottomRight
        }

        public static GraphicsPath Create(int x, int y, int width, int height,
                                          int radius, RectangleCorners corners)
        {
            int xw = x + width;
            int yh = y + height;
            int xwr = xw - radius;
            int yhr = yh - radius;
            int xr = x + radius;
            int yr = y + radius;
            int r2 = radius * 2;
            int xwr2 = xw - r2 - 1;
            int yhr2 = yh - r2 - 1;

            GraphicsPath p = new GraphicsPath();
            p.StartFigure();

            //Top Left Corner
            if ((RectangleCorners.TopLeft & corners) == RectangleCorners.TopLeft)
            {
                p.AddArc(x, y, r2, r2, 180, 90);
            }
            else
            {
                p.AddLine(x, yr, x, y);
                p.AddLine(x, y, xr, y);
            }

            //Top Edge
            p.AddLine(xr, y, xwr, y);

            //Top Right Corner
            if ((RectangleCorners.TopRight & corners) == RectangleCorners.TopRight)
            {
                p.AddArc(xwr2, y, r2, r2, 270, 90);
            }
            else
            {
                p.AddLine(xwr, y, xw, y);
                p.AddLine(xw, y, xw, yr);
            }

            //Right Edge
            p.AddLine(xw, yr, xw, yhr);

            //Bottom Right Corner
            if ((RectangleCorners.BottomRight & corners) == RectangleCorners.BottomRight)
            {
                p.AddArc(xwr2, yhr2, r2, r2, 0, 90);
            }
            else
            {
                p.AddLine(xw, yhr, xw, yh);
                p.AddLine(xw, yh, xwr, yh);
            }

            //Bottom Edge
            p.AddLine(xwr, yh, xr, yh);

            //Bottom Left Corner
            if ((RectangleCorners.BottomLeft & corners) == RectangleCorners.BottomLeft)
            {
                p.AddArc(x, yhr2, r2, r2, 90, 90);
            }
            else
            {
                p.AddLine(xr, yh, x, yh);
                p.AddLine(x, yh, x, yhr);
            }

            //Left Edge
            p.AddLine(x, yhr, x, yr);

            p.CloseFigure();
            return p;
        }

        public static GraphicsPath Create(Rectangle rect, int radius, RectangleCorners c)
        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius, c); }

        public static GraphicsPath Create(int x, int y, int width, int height, int radius)
        { return Create(x, y, width, height, radius, RectangleCorners.All); }

        public static GraphicsPath Create(Rectangle rect, int radius)
        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius); }

        public static GraphicsPath Create(int x, int y, int width, int height)
        { return Create(x, y, width, height, 5); }

        public static GraphicsPath Create(Rectangle rect)
        { return Create(rect.X, rect.Y, rect.Width, rect.Height); }
    }

    public static class GraphicsHelper
    {
        public static float GetTextWidthInPixels(string text, Font font)
        {
            var size = TextRenderer.MeasureText(text, font);
            return size.Width;
        }

        public static LinearGradientBrush CreateGradient(float width, float height, SolidBrush brush)
        {
            var linGrBrush = new LinearGradientBrush(
                new RectangleF(width, height, width, height),
                Color.FromArgb(255, brush.Color.R - 33, brush.Color.G - 33, brush.Color.B - 33),
                brush.Color, 90F);

            float[] relativeIntensities = { 0.0f, 0.5f, 1.0f };
            float[] relativePositions = { 0.0f, 0.2f, 1.0f };

            Blend blend = new Blend();
            blend.Factors = relativeIntensities;
            blend.Positions = relativePositions;
            linGrBrush.Blend = blend;

            return linGrBrush;
        }
    }

    // Created by DoggyCollin