using System;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace Sheng.Winform.Controls
{
    #region "EasyRender based renderer class"
    /// <summary>
    /// A ToolstripManager rendering class with advanced control features
    /// </summary>
    public class SEToolStripRender : ToolStripProfessionalRenderer
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new EasyRender class for modifications
        /// </summary>
        public SEToolStripRender()
        {
            _tsManager = new IToolstrip();
            _btnManager = new IButton();
            _dBtnManager = new IDropDownButton();
            _tsCtrlManager = new IToolstripControls();
            _pManager = new IPanel();
            _sBtnManager = new ISplitButton();
            _sBarManager = new IStatusBar();
            _mnuManager = new IMenustrip();
        }

        #endregion

        #region "Private variables"

        private readonly IToolstrip _tsManager = null;
        private readonly IButton _btnManager = null;
        private readonly IToolstripControls _tsCtrlManager = null;
        private readonly IPanel _pManager = null;
        private readonly ISplitButton _sBtnManager = null;
        private readonly IStatusBar _sBarManager = null;
        private readonly IMenustrip _mnuManager = null;
        private readonly IDropDownButton _dBtnManager = null;
        /// <summary>
        /// 
        /// </summary>
        protected Boolean _smoothText = true;
        /// <summary>
        /// 
        /// </summary>
        protected Color _overrideColor = Color.FromArgb(47, 92, 150);
        /// <summary>
        /// 
        /// </summary>
        protected Boolean _overrideText = true;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets the manager to edit and change the appearance of the Toolstrip
        /// </summary>
        [ReadOnly(true)]
        public IToolstrip Toolstrip
        {
            get
            {
                return _tsManager;
            }
        }

        /// <summary>
        /// Gets the manager to edit and change the appearance of Toolstrip buttons
        /// </summary>
        [ReadOnly(true)]
        public IButton ToolstripButton
        {
            get
            {
                return _btnManager;
            }
        }

        /// <summary>
        /// Gets the manager to edit and change the appearance of other Toolstrip controls
        /// </summary>
        [ReadOnly(true)]
        public IToolstripControls ToolstripControls
        {
            get { return _tsCtrlManager; }
        }

        /// <summary>
        /// Gets the manager to edit and change the appearance of the Panels
        /// </summary>
        [ReadOnly(true)]
        public IPanel Panels
        {
            get { return _pManager; }
        }

        /// <summary>
        /// Gets the manager to edit and change the appearance of the Toolstrip split buttons
        /// </summary>
        [ReadOnly(true)]
        public ISplitButton SplitButton
        {
            get { return _sBtnManager; }
        }

        /// <summary>
        /// Gets the manager to edit and change the appearance of the Status-bar
        /// </summary>
        [ReadOnly(true)]
        public IStatusBar StatusBar
        {
            get { return _sBarManager; }
        }

        /// <summary>
        /// Gets or sets whether to smooth the font text on all controls
        /// </summary>
        public Boolean SmoothText
        {
            get { return _smoothText; }
            set { _smoothText = value; }
        }

        /// <summary>
        /// Gets or sets the color of the text if the AlterColor is set to true
        /// </summary>
        public Color OverrideColor
        {
            get { return _overrideColor; }
            set { _overrideColor = value; }
        }

        /// <summary>
        /// Gets or sets whether to override the font-color on all controls
        /// </summary>
        public Boolean AlterColor
        {
            get { return _overrideText; }
            set { _overrideText = value; }
        }

        #endregion

        #region "Important -- Functions for getting drawing pointers"

        #region "CreatePanelBrush -- Gets a brush based on the docking position of a panel"
        /*
		/// <summary>
		/// Gets a brush dependent on the dock style of a panel
		/// </summary>
		/// <param name="Panel">The panel which is docked</param>
		/// <returns></returns>
		private Brush CreatePanelBrush(ToolStripPanel Panel)
		{
			switch (Panel.Dock)
			{
				case DockStyle.Top: return new SolidBrush(ContentPanelTop);
				case DockStyle.Bottom: return new SolidBrush(ContentPanelBottom);
				case DockStyle.Left:
				case DockStyle.Right:
					return new LinearGradientBrush(Panel.ClientRectangle, ContentPanelTop, ContentPanelBottom, 90f);
			}

			return null;
		}
		 */
        #endregion

        #region "CreateDrawingPath -- Gets a path based on a rectangular area and a provided curve value"
        /// <summary>
        /// Creates a GraphicsPath that appreciates an area where things can be drawn
        /// </summary>
        /// <param name="Area">The rectangular area which will serve as the base</param>
        /// <param name="Curve">The curve amount of the corners</param>
        /// <returns></returns>
        private GraphicsPath CreateDrawingPath(Rectangle Area, float Curve)
        {
            GraphicsPath Result = new GraphicsPath();

            Result.AddLine(Area.Left + Curve, Area.Top, Area.Right - Curve, Area.Top); // Top
            Result.AddLine(Area.Right - Curve, Area.Top, Area.Right, Area.Top + Curve); // Top-right
            Result.AddLine(Area.Right, Area.Top + Curve, Area.Right, Area.Bottom - Curve); // Right
            Result.AddLine(Area.Right, Area.Bottom - Curve, Area.Right - Curve, Area.Bottom); // Bottom-right
            Result.AddLine(Area.Right - Curve, Area.Bottom, Area.Left + Curve, Area.Bottom); // Bottom
            Result.AddLine(Area.Left + Curve, Area.Bottom, Area.Left, Area.Bottom - Curve); // Bottom-left
            Result.AddLine(Area.Left, Area.Bottom - Curve, Area.Left, Area.Top + Curve); // Left
            Result.AddLine(Area.Left, Area.Top + Curve, Area.Left + Curve, Area.Top); // Top-left

            return Result;
        }
        #endregion

        #region "CreateTrianglePath -- Gets a path based on a rectangle boundary as a triangle shape"
        /// <summary>
        /// Creates a triangle based on the size and bounds sectors
        /// </summary>
        /// <param name="Bounds">The area which the triangle is confined to</param>
        /// <param name="Size">The size of the triangle</param>
        /// <param name="Direction">The direction which the triangle is pointing</param>
        /// <returns></returns>
        private GraphicsPath CreateTrianglePath(Rectangle Bounds, Int32 Size, ArrowDirection Direction)
        {
            GraphicsPath Result = new GraphicsPath();
            int x, y, c, j;

            if (Direction == ArrowDirection.Left || Direction == ArrowDirection.Right)
            {
                x = Bounds.Right - (Bounds.Width - Size) / 2;
                y = Bounds.Y + Bounds.Height / 2;
                c = Size;
                j = 0;
            }
            else
            {
                x = Bounds.X + Bounds.Width / 2;
                y = Bounds.Bottom - ((Bounds.Height - (Size - 1)) / 2);
                c = Size - 1;
                j = Size - 2;
            }

            switch (Direction)
            {
                case ArrowDirection.Right:
                    Result.AddLine(x, y, x - c, y - c);
                    Result.AddLine(x - c, y - c, x - c, y + c);
                    Result.AddLine(x - c, y + c, x, y);
                    break;
                case ArrowDirection.Down:
                    Result.AddLine(x + j, y - j, x - j, y - j);
                    Result.AddLine(x - j, y - j, x, y);
                    Result.AddLine(x, y, x + j, y - j);
                    break;
                case ArrowDirection.Left:
                    Result.AddLine(x - c, y, x, y - c);
                    Result.AddLine(x, y - c, x, y + c);
                    Result.AddLine(x, y + c, x - c, y);
                    break;
            }

            return Result;
        }
        #endregion

        #region "GetButtonBackColor -- Returns different background gradient colors for a normal button state"
        /// <summary>
        /// Gets a color array based on the state of a normal button
        /// </summary>
        /// <param name="Item">The button to check the state of</param>
        /// <param name="Type"></param>
        /// <returns></returns>
        private Color[] GetButtonBackColor(ToolStripButton Item, ButtonType Type)
        {
            Color[] Return = new Color[2];

            if (
                (!Item.Selected) &&
                (!Item.Pressed && !Item.Checked)
                )
            {
                Return[0] = Color.Transparent;
                Return[1] = Color.Transparent;
            }
            else if (
                (Item.Selected) &&
                (!Item.Pressed && !Item.Checked)
                )
            {
                Return[0] = _btnManager.HoverBackgroundTop;
                Return[1] = _btnManager.HoverBackgroundBottom;
            }
            else
            {
                Return[0] = _btnManager.ClickBackgroundTop;
                Return[1] = _btnManager.ClickBackgroundBottom;
            }

            return Return;
        }
        #endregion

        #region "GetButtonBackColor -- Returns different background gradient colors for a split-button state"
        /// <summary>
        /// Gets a color array based on the state of a split-button
        /// </summary>
        /// <param name="Item">The button to check the state of</param>
        /// <param name="Type"></param>
        /// <returns></returns>
        private Color[] GetButtonBackColor(ToolStripSplitButton Item, ButtonType Type)
        {
            Color[] Return = new Color[2];

            if (
                (!Item.Selected) &&
                (!Item.ButtonPressed && !Item.DropDownButtonPressed)
                )
            {
                Return[0] = Color.Transparent;
                Return[1] = Color.Transparent;
            }
            else if (
                (Item.Selected) &&
                (!Item.ButtonPressed && !Item.DropDownButtonPressed)
                )
            {
                Return[0] = _sBtnManager.HoverBackgroundTop;
                Return[1] = _sBtnManager.HoverBackgroundBottom;
            }
            else
            {
                if (Item.ButtonPressed)
                {
                    Return[0] = _sBtnManager.ClickBackgroundTop;
                    Return[1] = _sBtnManager.ClickBackgroundBottom;
                }
                else if (Item.DropDownButtonPressed)
                {
                    Return[0] = _mnuManager.MenustripButtonBackground;
                    Return[1] = _mnuManager.MenustripButtonBackground;
                }
            }

            return Return;
        }
        #endregion

        #region "GetButtonBackColor -- Returns different background gradient colors for a menu-item state"
        /// <summary>
        /// Gets a color array based on the state of a menu-item
        /// </summary>
        /// <param name="Item">The button to check the state of</param>
        /// <param name="Type"></param>
        /// <returns></returns>
        private Color[] GetButtonBackColor(ToolStripMenuItem Item, ButtonType Type)
        {
            Color[] Return = new Color[2];

            if (
                (!Item.Selected) &&
                (!Item.Pressed && !Item.Checked)
                )
            {
                Return[0] = Color.Transparent;
                Return[1] = Color.Transparent;
            }
            else if (
                (Item.Selected || Item.Pressed) &&
                (!Item.Checked)
                )
            {
                if (Item.Pressed && Item.OwnerItem == null)
                {
                    Return[0] = _mnuManager.MenustripButtonBackground;
                    Return[1] = _mnuManager.MenustripButtonBackground;
                }
                else
                {
                    Return[0] = _mnuManager.Items.HoverBackgroundTop;
                    Return[1] = _mnuManager.Items.HoverBackgroundBottom;
                }
            }
            else
            {
                Return[0] = _mnuManager.Items.ClickBackgroundTop;
                Return[1] = _mnuManager.Items.ClickBackgroundBottom;
            }

            return Return;
        }
        #endregion

        #region "GetButtonBackColor -- Returns different background gradient colors for a dropdownbutton state"
        /// <summary>
        /// Gets a color array based on the state of a drop-down button
        /// </summary>
        /// <param name="Item">The button to check the state of</param>
        /// <param name="Type"></param>
        /// <returns></returns>
        private Color[] GetButtonBackColor(ToolStripDropDownButton Item, ButtonType Type)
        {
            Color[] Return = new Color[2];

            if (
                (!Item.Selected) &&
                (!Item.Pressed)
                )
            {
                Return[0] = Color.Transparent;
                Return[1] = Color.Transparent;
            }
            else if (
                (Item.Selected) &&
                (!Item.Pressed)
                )
            {
                Return[0] = _dBtnManager.HoverBackgroundTop;
                Return[1] = _dBtnManager.HoverBackgroundBottom;
            }
            else
            {
                Return[0] = _mnuManager.MenustripButtonBackground;
                Return[1] = _mnuManager.MenustripButtonBackground;
            }

            return Return;
        }
        #endregion

        #region "GetBlend -- Gets a blend property based on the blending options and current state"
        /// <summary>
        /// Gets a blending property for a specified type of Toolstrip item
        /// </summary>
        /// <param name="TSItem">The Toolstrip item</param>
        /// <param name="Type">The type of item this is</param>
        /// <returns></returns>
        private Blend GetBlend(ToolStripItem TSItem, ButtonType Type)
        {
            Blend BackBlend = null;

            if (Type == ButtonType.NormalButton)
            {
                ToolStripButton Item = (ToolStripButton)TSItem;

                if (Item.Selected &&
                    (!Item.Checked && !Item.Pressed) &&
                    (_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
                {
                    BackBlend = _btnManager.BackgroundBlend;
                }
                else if (Item.Pressed &&
                        (!Item.Checked) &&
                        (_btnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
                {
                    BackBlend = _btnManager.BackgroundBlend;
                }
                else if (Item.Checked &&
                        (_btnManager.BlendOptions & BlendRender.Check) == BlendRender.Check)
                {
                    BackBlend = _btnManager.BackgroundBlend;
                }
            }
            if (Type == ButtonType.DropDownButton)
            {
                ToolStripDropDownButton Item = (ToolStripDropDownButton)TSItem;

                if (Item.Selected &&
                    (!Item.Pressed) &&
                    (_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
                {
                    BackBlend = _btnManager.BackgroundBlend;
                }
            }
            else if (Type == ButtonType.MenuItem)
            {
                ToolStripMenuItem Item = (ToolStripMenuItem)TSItem;

                if (Item.Selected &&
                    (!Item.Checked && !Item.Pressed) &&
                    (_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
                {
                    BackBlend = _mnuManager.Items.BackgroundBlend;
                }
                else if (Item.Pressed &&
                        (!Item.Checked) &&
                        (_btnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
                {
                    BackBlend = _mnuManager.Items.BackgroundBlend;
                }
                else if (Item.Checked &&
                        (_btnManager.BlendOptions & BlendRender.Check) == BlendRender.Check)
                {
                    BackBlend = _mnuManager.Items.BackgroundBlend;
                }
            }
            else if (Type == ButtonType.SplitButton)
            {
                ToolStripSplitButton Item = (ToolStripSplitButton)TSItem;

                if (Item.Selected &&
                    (!Item.ButtonPressed && !Item.DropDownButtonPressed) &&
                    (_sBtnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
                {
                    BackBlend = _sBtnManager.BackgroundBlend;
                }
                else if (Item.ButtonPressed &&
                        (!Item.DropDownButtonPressed) &&
                        (_sBtnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
                {
                    BackBlend = _sBtnManager.BackgroundBlend;
                }
            }

            return BackBlend;
        }
        #endregion

        #endregion

        #region "Important -- Functions for drawing"

        #region "PaintBackground -- Simply fills a rectangle with a color"
        /// <summary>
        /// Fills a specified boundary with color
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Boundary">The boundaries to draw the color</param>
        /// <param name="Brush">The brush to fill the color</param>
        public void PaintBackground(Graphics Link, Rectangle Boundary, Brush Brush)
        {
            Link.FillRectangle(Brush, Boundary);
        }
        #endregion

        #region "PaintBackground -- Fills a rectangle with Top and Bottom colors"
        /// <summary>
        /// Fills a specified boundary with a gradient with specified colors
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Boundary">The boundaries to draw the color</param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom)
        {
            PaintBackground(Link, Boundary, Top, Bottom, 90f, null);
        }
        #endregion

        #region "PaintBackground -- Fills a rectangle with Top and Bottom colors at a given angle"
        /// <summary>
        /// Fills a specified boundary with a gradient with specified colors at a given angle
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Boundary">The boundaries to draw the color</param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        /// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
        public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom, float Angle)
        {
            PaintBackground(Link, Boundary, Top, Bottom, Angle, null);
        }
        #endregion

        #region "PaintBackground -- Fills a rectangle with Top and Bottom colors at a given angle with blending"
        /// <summary>
        /// Fills a specified boundary with a gradient with specified colors at a given angle and with blending properties
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Boundary">The boundaries to draw the color</param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        /// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
        /// <param name="Blend">The blending options to draw the gradient</param>
        public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom, float Angle, Blend Blend)
        {
            if ( float.IsNaN(Angle))
            {
                Angle = 90f;
            }

            using (LinearGradientBrush Fill = new LinearGradientBrush(Boundary, Top, Bottom, Angle))
            {
                if (Blend != null)
                {
                    Fill.Blend = Blend;
                }

                Link.FillRectangle(Fill, Boundary);
                Fill.Dispose();
            }
        }
        #endregion

        #region "PaintBorder -- Draws a border along a set path"
        /// <summary>
        /// Draws a set path with a defined brush
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Path">The path to draw along</param>
        /// <param name="Brush">The brush to fill the color</param>
        public void PaintBorder(Graphics Link, GraphicsPath Path, Brush Brush)
        {
            Link.DrawPath(new Pen(Brush), Path);
        }
        #endregion

        #region "PaintBorder -- Draws a border along a set path with Top and Bottom colors"
        /// <summary>
        /// Draws a set path with specified colors
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Path">The path to draw along</param>
        /// <param name="Area">The area of span the border gradient covers</param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom)
        {
            PaintBorder(Link, Path, Area, Top, Bottom, 90f, null);
        }
        #endregion

        #region "PaintBorder -- Draws a border along a set path with Top and Bottom colors at a given angle"
        /// <summary>
        /// Draws a set path with specified colors at a given angle
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Path">The path to draw along</param>
        /// <param name="Area">The area of span the border gradient covers</param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        /// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
        public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom, float Angle)
        {
            PaintBorder(Link, Path, Area, Top, Bottom, Angle, null);
        }
        #endregion

        #region "PaintBorder -- Draws a border along a set path with Top and Bottom colors at a given angle with blending"
        /// <summary>
        /// Draws a set path with specified colors at a given angle with blending properties
        /// </summary>
        /// <param name="Link">The Graphics object to draw onto</param>
        /// <param name="Path">The path to draw along</param>
        /// <param name="Area"></param>
        /// <param name="Top">The color of the gradient at the top</param>
        /// <param name="Bottom">The color of the gradient at the bottom</param>
        /// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
        /// <param name="Blend">The blending options to draw the gradient</param>
        public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom, float Angle, Blend Blend)
        {

            if (float.IsNaN(Angle))
            {
                Angle = 90f;
            }

            using (LinearGradientBrush Fill = new LinearGradientBrush(Area, Top, Bottom, Angle))
            {
                if (Blend != null)
                {
                    Fill.Blend = Blend;
                }

                Link.DrawPath(new Pen(Fill), Path);
                Fill.Dispose();
            }
        }
        #endregion

        #endregion

        #region "Important -- Functions handling the OnRender delegations"

        #region "IDrawToolstripButton -- Draws a Toolstrip button applying the backround and border"
        /// <summary>
        /// Draws a Toolstrip button
        /// </summary>
        /// <param name="Item">The Toolstrip button</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Parent">The parent Toolstrip</param>
        public void IDrawToolstripButton(ToolStripButton Item, Graphics Link, ToolStrip Parent)
        {
            Rectangle Area = new Rectangle(
                                new Point(0, 0),
                                new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
                            );

            Blend BackBlend = GetBlend(Item, ButtonType.NormalButton);
            Color[] Render = GetButtonBackColor(Item, ButtonType.NormalButton);

            using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
            {
                Link.SetClip(Path);

                PaintBackground(
                            Link,
                            Area,
                            Render[0],
                            Render[1],
                            _btnManager.BackgroundAngle,
                            BackBlend
                            );

                Link.ResetClip();

                Link.SmoothingMode = SmoothingMode.AntiAlias;

                using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
                {
                    PaintBorder(
                                Link,
                                OBPath,
                                Area,
                                _btnManager.BorderTop,
                                _btnManager.BorderBottom,
                                _btnManager.BorderAngle,
                                _btnManager.BorderBlend
                                );

                    OBPath.Dispose();
                }

                Area.Inflate(-1, -1);

                using (GraphicsPath IBPath = CreateDrawingPath(Area, _btnManager.Curve))
                {
                    using (SolidBrush InnerBorder = new SolidBrush(_btnManager.InnerBorder))
                    {
                        PaintBorder(
                                    Link,
                                    IBPath,
                                    InnerBorder
                                    );

                        InnerBorder.Dispose();
                    }
                }

                Link.SmoothingMode = SmoothingMode.Default;
            }
        }
        #endregion

        #region "IDrawDropDownButton -- Draws a Toolstrip dropdownbutton applying the backround and border"
        /// <summary>
        /// Draws a Toolstrip button
        /// </summary>
        /// <param name="Item">The Toolstrip button</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Parent">The parent Toolstrip</param>
        public void IDrawDropDownButton(ToolStripDropDownButton Item, Graphics Link, ToolStrip Parent)
        {
            Rectangle Area = new Rectangle(
                                new Point(0, 0),
                                new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
                            );

            Blend BackBlend = GetBlend(Item, ButtonType.DropDownButton);
            Color[] Render = GetButtonBackColor(Item, ButtonType.DropDownButton);

            using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
            {
                Link.SetClip(Path);

                PaintBackground(
                            Link,
                            Area,
                            Render[0],
                            Render[1],
                            _btnManager.BackgroundAngle,
                            BackBlend
                            );

                Link.ResetClip();

                Link.SmoothingMode = SmoothingMode.AntiAlias;

                using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
                {
                    PaintBorder(
                                Link,
                                OBPath,
                                Area,
                                _btnManager.BorderTop,
                                _btnManager.BorderBottom,
                                _btnManager.BorderAngle,
                                _btnManager.BorderBlend
                                );

                    OBPath.Dispose();
                }

                if (!Item.Pressed)
                {
                    Area.Inflate(-1, -1);

                    using (GraphicsPath IBPath = CreateDrawingPath(Area, _dBtnManager.Curve))
                    {
                        using (SolidBrush InnerBorder = new SolidBrush(_dBtnManager.InnerBorder))
                        {
                            PaintBorder(
                                        Link,
                                        IBPath,
                                        InnerBorder
                                        );

                            InnerBorder.Dispose();
                        }
                    }
                }

                Link.SmoothingMode = SmoothingMode.Default;
            }
        }
        #endregion

        #region "IDrawToolstripBackground -- Draws a Toolstrip background"
        /// <summary>
        /// Draws the Toolstrip background
        /// </summary>
        /// <param name="Item">The Toolstrip being drawn</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Bounds">The affected bounds</param>
        public void IDrawToolstripBackground(ToolStrip Item, Graphics Link, Rectangle Bounds)
        {
            Rectangle Area = new Rectangle(
                                0,
                                0,
                                Bounds.Width - 1,
                                Bounds.Height - 1
                                );

            Link.SmoothingMode = SmoothingMode.None;

            using (GraphicsPath Path = CreateDrawingPath(Area, _tsManager.Curve))
            {
                Link.SetClip(Path);

                PaintBackground(
                                Link,
                                Area,
                                _tsManager.BackgroundTop,
                                _tsManager.BackgroundBottom,
                                _tsManager.BackgroundAngle,
                                _tsManager.BackgroundBlend
                                );

                Link.ResetClip();

                Path.Dispose();
            }
        }
        #endregion

        #region "IDrawToolstripSplitButton -- Draws a Toolstrip split-button with the arrow"
        /// <summary>
        /// Draws a Toolstrip split-button
        /// </summary>
        /// <param name="Item">The Toolstrip split-button</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Parent">The parent Toolstrip</param>
        public void IDrawToolstripSplitButton(ToolStripSplitButton Item, Graphics Link, ToolStrip Parent)
        {
            if (Item.Selected || Item.DropDownButtonPressed || Item.ButtonPressed)
            {
                Rectangle Area = new Rectangle(
                                        new Point(0, 0),
                                        new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
                                        );

                Blend BackBlend = GetBlend(Item, ButtonType.SplitButton);
                Color[] NormalRender = new Color[] { _sBtnManager.HoverBackgroundTop, _sBtnManager.HoverBackgroundBottom };
                Color[] Render = GetButtonBackColor(Item, ButtonType.SplitButton);

                using (GraphicsPath Path = CreateDrawingPath(Area, _sBtnManager.Curve))
                {
                    Link.SetClip(Path);

                    if (!Item.DropDownButtonPressed)
                    {
                        PaintBackground(
                                        Link,
                                        Area,
                                        NormalRender[0],
                                        NormalRender[1],
                                        _sBtnManager.BackgroundAngle,
                                        BackBlend
                                        );
                    }
                    else
                    {
                        PaintBackground(
                                        Link,
                                        Area,
                                        Render[0],
                                        Render[1]
                                        );
                    }

                    if (Item.ButtonPressed)
                    {
                        Rectangle ButtonArea = new Rectangle(
                                                    new Point(0, 0),
                                                    new Size(Item.ButtonBounds.Width, Item.ButtonBounds.Height - 1)
                                                    );

                        PaintBackground(
                                        Link,
                                        ButtonArea,
                                        Render[0],
                                        Render[1],
                                        _sBtnManager.BackgroundAngle,
                                        _sBtnManager.BackgroundBlend
                                        );
                    }

                    Link.ResetClip();

                    Link.SmoothingMode = SmoothingMode.AntiAlias;

                    using (GraphicsPath OBPath = CreateDrawingPath(Area, _sBtnManager.Curve))
                    {
                        Color TopColor = (Item.DropDownButtonPressed ? _mnuManager.MenustripButtonBorder : _sBtnManager.BorderTop);
                        Color BottomColor = (Item.DropDownButtonPressed ? _mnuManager.MenustripButtonBorder : _sBtnManager.BorderBottom);

                        PaintBorder(
                                    Link,
                                    OBPath,
                                    Area,
                                    TopColor,
                                    BottomColor,
                                    _sBtnManager.BorderAngle,
                                    _sBtnManager.BorderBlend
                                    );

                        OBPath.Dispose();
                    }

                    if (!Item.DropDownButtonPressed)
                    {
                        Area.Inflate(-1, -1);

                        using (GraphicsPath IBPath = CreateDrawingPath(Area, _sBtnManager.Curve))
                        {
                            using (SolidBrush InnerBorder = new SolidBrush(_sBtnManager.InnerBorder))
                            {
                                PaintBorder(
                                            Link,
                                            IBPath,
                                            InnerBorder
                                            );


                                Link.DrawRectangle(
                                                new Pen(_sBtnManager.InnerBorder),
                                                new Rectangle(
                                                            Item.ButtonBounds.Width,
                                                            1,
                                                            2,
                                                            Item.ButtonBounds.Height - 3
                                                            )
                                                    );

                                InnerBorder.Dispose();
                            }
                        }

                        using (LinearGradientBrush SplitLine = new LinearGradientBrush(
                                                                            new Rectangle(0, 0, 1, Item.Height),
                                                                            _sBtnManager.BorderTop,
                                                                            _sBtnManager.BorderBottom,
                                                                            _sBtnManager.BackgroundAngle
                                                                            ))
                        {
                            if (_sBtnManager.BackgroundBlend != null)
                            {
                                SplitLine.Blend = _sBtnManager.BackgroundBlend;
                            }

                            Link.DrawLine(
                                        new Pen(SplitLine),
                                        Item.ButtonBounds.Width + 1,
                                        0,
                                        Item.ButtonBounds.Width + 1,
                                        Item.Height - 1
                                        );

                            SplitLine.Dispose();
                        }
                    }

                    Link.SmoothingMode = SmoothingMode.Default;
                }
            }

            Int32 ArrowSize = 5;

            if (
                (_sBtnManager.ArrowDisplay == ArrowDisplay.Always) ||
                (_sBtnManager.ArrowDisplay == ArrowDisplay.Hover && Item.Selected)
                )
            {
                using (GraphicsPath TrianglePath = CreateTrianglePath(
                                                new Rectangle(
                                                        Item.DropDownButtonBounds.Left + (ArrowSize / 2) - 1,
                                                        (Item.DropDownButtonBounds.Height / 2) - (ArrowSize / 2) - 3,
                                                        ArrowSize * 2,
                                                        ArrowSize * 2
                                                        ),
                                                ArrowSize,
                                                ArrowDirection.Down
                                                ))
                {
                    Link.FillPath(new SolidBrush(_sBtnManager.ArrowColor), TrianglePath);

                    TrianglePath.Dispose();
                }

            }
        }
        #endregion

        #region "IDrawStatusbarBackground -- Draws the statusbar background"
        /// <summary>
        /// Draws the Statusbar background
        /// </summary>
        /// <param name="Item">The Statusbar being drawn</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Bounds">The affected bounds</param>
        public void IDrawStatusbarBackground(StatusStrip Item, Graphics Link, Rectangle Bounds)
        {
            PaintBackground(
                        Link,
                        Bounds,
                        _sBarManager.BackgroundTop,
                        _sBarManager.BackgroundBottom,
                        _sBarManager.BackgroundAngle,
                        _sBarManager.BackgroundBlend
                        );

            Link.DrawLine(
                        new Pen(_sBarManager.DarkBorder),
                        0, 0, Bounds.Width, 0
                        );

            Link.DrawLine(
                        new Pen(_sBarManager.LightBorder),
                        0, 1, Bounds.Width, 1
                        );
        }
        #endregion

        #region "IDrawMenustripItem -- Draws a Menustrip item applying the background and border"
        /// <summary>
        /// Draws a Menustrip item
        /// </summary>
        /// <param name="Item">The Menustrip item</param>
        /// <param name="Link">The Graphics object to handle</param>
        /// <param name="Parent">The parent Toolstrip</param>
        public void IDrawMenustripItem(ToolStripMenuItem Item, Graphics Link, ToolStrip Parent)
        {
            Rectangle Area = new Rectangle(
                                new Point(0, 0),
                                new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
                            );

            if (Item.OwnerItem != null)
            {
                Area.X += 2;
                Area.Width -= 3;
            }

            Blend BackBlend = GetBlend(Item, ButtonType.MenuItem);
            Color[] Render = GetButtonBackColor(Item, ButtonType.MenuItem);

            using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
            {
                Link.SetClip(Path);

                PaintBackground(
                            Link,
                            Area,
                            Render[0],
                            Render[1],
                            _btnManager.BackgroundAngle,
                            BackBlend
                            );

                Link.ResetClip();

                Link.SmoothingMode = SmoothingMode.AntiAlias;

                using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
                {
                    PaintBorder(
                                Link,
                                OBPath,
                                Area,
                                _mnuManager.MenustripButtonBorder,
                                _mnuManager.MenustripButtonBorder,
                                _btnManager.BorderAngle,
                                _btnManager.BorderBlend
                                );

                    OBPath.Dispose();
                }

                if (!Item.Pressed)
                {
                    Area.Inflate(-1, -1);

                    using (GraphicsPath IBPath = CreateDrawingPath(Area, _btnManager.Curve))
                    {
                        using (SolidBrush InnerBorder = new SolidBrush(_btnManager.InnerBorder))
                        {
                            PaintBorder(
                                        Link,
                                        IBPath,
                                        InnerBorder
                                        );

                            InnerBorder.Dispose();
                        }
                    }
                }

                Link.SmoothingMode = SmoothingMode.Default;
            }
        }
        #endregion

        #endregion

        #region "Important* -- The OnRender protected overrides"

        #region "Render Button Background -- Handles drawing toolstrip/menu/status-strip buttons"
        /// <summary>
        /// Covers the button background rendering
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (
                e.ToolStrip is ContextMenuStrip ||
                e.ToolStrip is ToolStripDropDownMenu ||
                e.ToolStrip is MenuStrip
                )
            {
                ToolStripMenuItem Item = (ToolStripMenuItem)e.Item;

                if (Item.Selected || Item.Checked || Item.Pressed)
                    IDrawMenustripItem(Item, e.Graphics, e.ToolStrip);
            }
            else if (
                e.ToolStrip is StatusStrip
                )
            {
            }
            else
            {
                ToolStripButton Item = (ToolStripButton)e.Item;

                if (Item.Selected || Item.Checked || Item.Pressed)
                    IDrawToolstripButton(Item, e.Graphics, e.ToolStrip);
            }
        }
        #endregion

        #region "Render Dropdown Button Background"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (e.Item.Selected || e.Item.Pressed)
                IDrawDropDownButton((ToolStripDropDownButton)e.Item, e.Graphics, e.ToolStrip);
        }
        #endregion

        #region "Render Image Margin -- Handles drawing the image margin on drop-down menus"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderImageMargin(ToolStripRenderEventArgs e)
        {
            Rectangle Area = new Rectangle(
                                        2,
                                        2,
                                        e.AffectedBounds.Width,
                                        e.AffectedBounds.Height - 4
                                        );

            PaintBackground(e.Graphics, Area, _mnuManager.MarginLeft, _mnuManager.MarginRight, 0f);

            e.Graphics.DrawLine(
                            new Pen(_mnuManager.MenuBorderDark),
                            e.AffectedBounds.Width + 1,
                            2,
                            e.AffectedBounds.Width + 1,
                            e.AffectedBounds.Height - 3
                            );
        }
        #endregion

        #region "Render Item Text -- Allows smoothing of text and changing the color"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e)
        {
            if (_smoothText)
                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

            if (_overrideText)
                e.TextColor = _overrideColor;

            base.OnRenderItemText(e);
        }
        #endregion

        #region "Render Menuitem Background -- Handles drawing menu-item backgrounds"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e)
        {
            ToolStripMenuItem Item = (ToolStripMenuItem)e.Item;

            if ((!Item.Selected && !Item.Checked && !Item.Pressed) || Item.Enabled == false)
            {
                return;
            }

            if (
                e.ToolStrip is MenuStrip ||
                e.ToolStrip is ToolStripDropDownMenu ||
                e.ToolStrip is ContextMenuStrip
                )
            {
                IDrawMenustripItem(Item, e.Graphics, e.ToolStrip);
            }
        }
        #endregion

        #region "Render Seperator -- Handles drawing the seperator for the toolstrip and contextmenu controls"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e)
        {
            if (
                e.ToolStrip is ContextMenuStrip ||
                e.ToolStrip is ToolStripDropDownMenu
                )
            {
                // Draw it

                e.Graphics.DrawLine(new Pen(_mnuManager.SeperatorDark), _mnuManager.SeperatorInset, 3, e.Item.Width + 1, 3);
                e.Graphics.DrawLine(new Pen(_mnuManager.SeperatorLight), _mnuManager.SeperatorInset, 4, e.Item.Width + 1, 4);
            }
            else
            {
                if (e.Vertical)
                {
                    e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorDark), 3, 5, 3, e.Item.Height - 6);
                    e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorLight), 4, 6, 4, e.Item.Height - 6);
                }
                else
                {
                    e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorDark), 8, 0, e.Item.Width - 6, 0);
                    e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorLight), 9, 1, e.Item.Width - 6, 1);
                }
            }
        }
        #endregion

        #region "Render SplitButton Background -- Handles drawing the split button"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e)
        {
            ToolStripSplitButton Item = (ToolStripSplitButton)e.Item;

            IDrawToolstripSplitButton(Item, e.Graphics, e.ToolStrip);
        }
        #endregion

        #region "Render Statusstrip Sizing Grip"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderStatusStripSizingGrip(ToolStripRenderEventArgs e)
        {
            using (SolidBrush Top = new SolidBrush(_sBarManager.GripTop),
                              Bottom = new SolidBrush(_sBarManager.GripBottom))
            {
                Int32 d = _sBarManager.GripSpacing;
                Int32 y = e.AffectedBounds.Bottom - (d * 4);

                for (int a = 1; a < 4; a++)
                {
                    y += d;

                    for (int b = 1; a >= b; b++)
                    {
                        Int32 x = e.AffectedBounds.Right - (d * b);

                        e.Graphics.FillRectangle(Bottom, x + 1, y + 1, 2, 2);
                        e.Graphics.FillRectangle(Top, x, y, 2, 2);
                    }
                }
            }
        }
        #endregion

        #region "Render Toolstrip Background -- Handles drawing toolstrip/menu/status-strip backgrounds"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
        {
            if (
                e.ToolStrip is ContextMenuStrip ||
                e.ToolStrip is ToolStripDropDownMenu
                )
            {
                PaintBackground(e.Graphics, e.AffectedBounds, _mnuManager.BackgroundTop, _mnuManager.BackgroundBottom, 90f, _mnuManager.BackgroundBlend);

                Rectangle Border = new Rectangle(
                                            0,
                                            0,
                                            e.AffectedBounds.Width - 1,
                                            e.AffectedBounds.Height - 1
                                            );

                using (GraphicsPath Path = CreateDrawingPath(Border, 0))
                {
                    e.Graphics.ExcludeClip(new Rectangle(
                                                    1,
                                                    0,
                                                    e.ConnectedArea.Width,
                                                    e.ConnectedArea.Height - 1
                                                    ));

                    PaintBorder(e.Graphics, Path, new SolidBrush(_mnuManager.MenuBorderDark));

                    e.Graphics.ResetClip();

                    Path.Dispose();
                }
            }
            else if (
                e.ToolStrip is MenuStrip)
            {
                Rectangle Area = e.AffectedBounds;

                PaintBackground(e.Graphics, Area, new SolidBrush(_pManager.ContentPanelTop));
            }
            else if (
                e.ToolStrip is StatusStrip strip
                )
            {
                IDrawStatusbarBackground(strip, e.Graphics, e.AffectedBounds);
            }
            else
            {
                e.ToolStrip.BackColor = Color.Transparent;

                IDrawToolstripBackground(e.ToolStrip, e.Graphics, e.AffectedBounds);
            }
        }
        #endregion

        #region "Render Toolstrip Border -- Handles drawing the border for toolstrip/menu/status-strip controls"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e)
        {
            if (
                e.ToolStrip is ContextMenuStrip ||
                e.ToolStrip is ToolStripDropDownMenu
                )
            {
            }
            else if (
                e.ToolStrip is StatusStrip
                )
            {
            }
            else if (
                e.ToolStrip is MenuStrip
                )
            {
            }
            else
            {
                Rectangle Area = new Rectangle(
                                        0,
                                        -2,
                                        e.AffectedBounds.Width - 2,
                                        e.AffectedBounds.Height + 1
                                        );
                using (GraphicsPath Path = CreateDrawingPath(Area, _tsManager.Curve))
                {
                    PaintBorder(
                                e.Graphics,
                                Path,
                                e.AffectedBounds,
                                _tsManager.BorderTop,
                                _tsManager.BorderBottom,
                                _tsManager.BorderAngle,
                                _tsManager.BorderBlend
                                );

                    Path.Dispose();
                }
            }
        }
        #endregion

        #region "Render Toolstrip Content Panel Background -- Handles drawing the content panel background"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e)
        {
            if (e.ToolStripContentPanel.ClientRectangle.Width < 3 || e.ToolStripContentPanel.ClientRectangle.Height < 3)
            {
                return;
            }

            e.Handled = true;

            e.Graphics.SmoothingMode = _pManager.Mode;

            PaintBackground(
                        e.Graphics,
                        e.ToolStripContentPanel.ClientRectangle,
                        _pManager.ContentPanelTop,
                        _pManager.ContentPanelBottom,
                        _pManager.BackgroundAngle,
                        _pManager.BackgroundBlend
                        );
        }
        #endregion

        #region "Render Toolstrip Panel Background -- Handles drawing the backgrounds for each panel"
        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e)
        {
            if (e.ToolStripPanel.ClientRectangle.Width < 3 || e.ToolStripPanel.ClientRectangle.Height < 3)
                return;

            e.Handled = true;

            switch (e.ToolStripPanel.Dock)
            {
                case DockStyle.Top:
                    PaintBackground(
                                    e.Graphics,
                                    e.ToolStripPanel.ClientRectangle,
                                    new SolidBrush(_pManager.ContentPanelTop)
                                    );
                    break;

                case DockStyle.Bottom:
                    PaintBackground(
                                    e.Graphics,
                                    e.ToolStripPanel.ClientRectangle,
                                    new SolidBrush(_pManager.ContentPanelBottom)
                                    );
                    break;

                case DockStyle.Left:
                case DockStyle.Right:
                    PaintBackground(
                                    e.Graphics,
                                    e.ToolStripPanel.ClientRectangle,
                                    _pManager.ContentPanelTop,
                                    _pManager.ContentPanelBottom,
                                    _pManager.BackgroundAngle,
                                    _pManager.BackgroundBlend
                                    );
                    break;
            }
        }
        #endregion

        #endregion

        #region "Other functions"

        #region "Apply -- Applies any recent changes to the renderer"
        /// <summary>
        /// Applies any and all changes made to the Renderer
        /// </summary>
        public void Apply()
        {
            ToolStripManager.Renderer = this;
        }
        #endregion

        #endregion
    }
    #endregion

    #region "EasyRender -- Toolstrip controlling class"
    /// <summary>
    /// A class designed to be used in the EasyRender master control to customize the look and feel of the base Toolstrip
    /// </summary>
    public class IToolstrip : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IToolstrip class for customization
        /// </summary>
        public IToolstrip()
        {
            DefaultBlending();
        }

        /// <summary>
        /// Creates a new IToolstrip class for customization
        /// </summary>
        /// <param name="Import">The IToolstrip to import the settings from</param>
        public IToolstrip(IToolstrip Import)
        {
            DefaultBlending();

            Apply(Import);
        }

        /// <summary>
        /// Disposes of the IToolstrip class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private int _curve = 2;

        private Color _borderTop = Color.Transparent;
        private Color _borderBottom = Color.FromArgb(71, 117, 177);
        private Blend _borderBlend = null;
        private float _borderAngle = 90;

        private Color _backTop = Color.FromArgb(227, 239, 255);
        private Color _backBottom = Color.FromArgb(163, 193, 234);
        private Blend _backBlend = null;
        private float _backAngle = 90;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the Toolstrip background gradient from the top
        /// </summary>
        public Color BackgroundTop
        {
            get
            {
                return _backTop;
            }

            set
            {
                _backTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Toolstrip background gradient from the bottom
        /// </summary>
        public Color BackgroundBottom
        {
            get
            {
                return _backBottom;
            }

            set
            {
                _backBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Toolstrip background
        /// If set to null, the Toolstrip will simply draw the gradient
        /// </summary>
        public Blend BackgroundBlend
        {
            get
            {
                return _backBlend;
            }

            set
            {
                _backBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Toolstrip background will be drawn
        /// </summary>
        public float BackgroundAngle
        {
            get
            {
                return _backAngle;
            }

            set
            {
                _backAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Toolstrip border gradient from the top
        /// </summary>
        public Color BorderTop
        {
            get
            {
                return _borderTop;
            }

            set
            {
                _borderTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Toolstrip border gradient from the bottom
        /// </summary>
        public Color BorderBottom
        {
            get
            {
                return _borderBottom;
            }

            set
            {
                _borderBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Toolstrip border
        /// If set to null, the Toolstrip will simply draw the border
        /// </summary>
        public Blend BorderBlend
        {
            get
            {
                return _borderBlend;
            }

            set
            {
                _borderBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Toolstrip border will be drawn
        /// </summary>
        public float BorderAngle
        {
            get
            {
                return _borderAngle;
            }

            set
            {
                _borderAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the curve of the border of the Toolstrip
        /// </summary>
        public int Curve
        {
            get
            {
                return _curve;
            }

            set
            {
                _curve = value;
            }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IToolstrip and applies it to the current
        /// </summary>
        /// <param name="Import">The IToolstrip to import the settings from</param>
        public void Apply(IToolstrip Import)
        {
            _backTop = Import._borderTop;
            _backBottom = Import._borderBottom;
            _backAngle = Import._borderAngle;
            _backBlend = Import._backBlend;

            _borderTop = Import._borderTop;
            _borderBottom = Import._borderBottom;
            _borderAngle = Import._borderAngle;
            _borderBlend = Import._borderBlend;

            _curve = Import._curve;
        }

        /// <summary>
        /// Sets the blending for both border and background to their defaults
        /// </summary>
        public void DefaultBlending()
        {
            _borderBlend = new Blend
            {
                Positions = new float[] { 0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1f },
                Factors = new float[] { 0.1f, 0.2f, 0.3f, 0.3f, 0.3f, 0.4f, 0.4f, 0.4f, 0.5f, 0.7f, 0.7f }
            };

            _backBlend = new Blend
            {
                Positions = new float[] { 0f, 0.3f, 0.5f, 0.8f, 1f },
                Factors = new float[] { 0f, 0f, 0f, 0.5f, 1f }
            };
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Toolstrip extended controls"
    /// <summary>
    /// 
    /// </summary>
    public class IToolstripControls : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IToolstripControls class for customization
        /// </summary>
        public IToolstripControls()
        {
        }

        /// <summary>
        /// Disposes of the IToolstripControls class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _sepDark = Color.FromArgb(154, 198, 255);
        private Color _sepLight = Color.White;
        private int _sepHeight = 8;

        private Color _gripTop = Color.FromArgb(111, 157, 217);
        private Color _gripBottom = Color.White;
        private GripType _gripStyle = GripType.Dotted;
        private int _gripDistance = 4;
        private Size _gripSize = new Size(2, 2);

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the Toolstrip seperator on the dark side
        /// </summary>
        public Color SeperatorDark
        {
            get
            {
                return _sepDark;
            }

            set
            {
                _sepDark = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Toolstrip seperator on the light side
        /// </summary>
        public Color SeperatorLight
        {
            get
            {
                return _sepLight;
            }

            set
            {
                _sepLight = value;
            }
        }

        /// <summary>
        /// Gets or sets the height of the Toolstrip seperator control
        /// </summary>
        public int SeperatorHeight
        {
            get
            {
                return _sepHeight;
            }

            set
            {
                _sepHeight = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the grip dots/line at the top
        /// </summary>
        public Color GripTop
        {
            get
            {
                return _gripTop;
            }

            set
            {
                _gripTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the grip shadow
        /// </summary>
        public Color GripShadow
        {
            get
            {
                return _gripBottom;
            }

            set
            {
                _gripBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets in what mode the grip will be drawn
        /// </summary>
        public GripType GripStyle
        {
            get { return _gripStyle; }
            set { _gripStyle = value; }
        }

        /// <summary>
        /// Gets or sets the distance, in pixels, between each grip dot
        /// </summary>
        public int GripDistance
        {
            get { return _gripDistance; }
            set { _gripDistance = value; }
        }

        /// <summary>
        /// Gets or sets the size of the dots or lines for the grip
        /// </summary>
        public Size GripSize
        {
            get { return _gripSize; }
            set { _gripSize = value; }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IToolstripControls and applies it to the current
        /// </summary>
        /// <param name="Import">The IToolstripControls to import the settings from</param>
        public void Apply(IToolstripControls Import)
        {
            _sepDark = Import._sepDark;
            _sepLight = Import._sepLight;
            _sepHeight = Import._sepHeight;

            _gripTop = Import._gripTop;
            _gripBottom = Import._gripBottom;
            _gripDistance = Import._gripDistance;
            _gripStyle = Import._gripStyle;
            _gripSize = Import._gripSize;
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Button controlling class"
    /// <summary>
    /// 
    /// </summary>
    public class IButton : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IButton class for customization
        /// </summary>
        public IButton()
        {
            DefaultBlending();
        }

        /// <summary>
        /// Creates a new IButton class for customization
        /// </summary>
        /// <param name="Import">The IButton to import the settings from</param>
        public IButton(IButton Import)
        {
            DefaultBlending();

            Apply(Import);
        }

        /// <summary>
        /// Disposes of the IButton class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _borderTop = Color.FromArgb(157, 183, 217);
        private Color _borderBottom = Color.FromArgb(157, 183, 217);
        private Color _borderInner = Color.FromArgb(255, 247, 185);
        private Blend _borderBlend = null;
        private float _borderAngle = 90f;

        private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
        private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);

        private Color _clickBackTop = Color.FromArgb(245, 207, 57);
        private Color _clickBackBottom = Color.FromArgb(245, 225, 124);

        private float _backAngle = 90f;
        private Blend _backBlend = null;

        private BlendRender _blendRender = BlendRender.Hover | BlendRender.Click | BlendRender.Check;
        private int _curve = 1;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the Button background at the top, when hovered over
        /// </summary>
        public Color HoverBackgroundTop
        {
            get
            {
                return _hoverBackTop;
            }

            set
            {
                _hoverBackTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the bottom, when hovered over
        /// </summary>
        public Color HoverBackgroundBottom
        {
            get
            {
                return _hoverBackBottom;
            }

            set
            {
                _hoverBackBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the top, when clicked
        /// </summary>
        public Color ClickBackgroundTop
        {
            get
            {
                return _clickBackTop;
            }

            set
            {
                _clickBackTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the bottom, when clicked
        /// </summary>
        public Color ClickBackgroundBottom
        {
            get
            {
                return _clickBackBottom;
            }

            set
            {
                _clickBackBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button background
        /// If set to null, the Button will simply draw the gradient
        /// </summary>
        public Blend BackgroundBlend
        {
            get
            {
                return _backBlend;
            }

            set
            {
                _backBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button background will be drawn
        /// </summary>
        public float BackgroundAngle
        {
            get
            {
                return _backAngle;
            }

            set
            {
                _backAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the top
        /// </summary>
        public Color BorderTop
        {
            get
            {
                return _borderTop;
            }

            set
            {
                _borderTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the bottom
        /// </summary>
        public Color BorderBottom
        {
            get
            {
                return _borderBottom;
            }

            set
            {
                _borderBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button border
        /// If set to null, the Button will simply draw the border
        /// </summary>
        public Blend BorderBlend
        {
            get
            {
                return _borderBlend;
            }

            set
            {
                _borderBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button border will be drawn
        /// </summary>
        public float BorderAngle
        {
            get
            {
                return _borderAngle;
            }

            set
            {
                _borderAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the inside border
        /// </summary>
        public Color InnerBorder
        {
            get { return _borderInner; }
            set { _borderInner = value; }
        }

        /// <summary>
        /// Gets or sets when to apply the rendering ("Normal" does not apply here)
        /// </summary>
        public BlendRender BlendOptions
        {
            get
            {
                return _blendRender;
            }

            set
            {
                _blendRender = value;
            }
        }

        /// <summary>
        /// Gets or sets the curve of the border of the Button
        /// </summary>
        public int Curve
        {
            get
            {
                return _curve;
            }

            set
            {
                _curve = value;
            }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IButton and applies it to the current
        /// </summary>
        /// <param name="Import">The IButton to import the settings from</param>
        public void Apply(IButton Import)
        {
            _borderTop = Import._borderTop;
            _borderBottom = Import._borderBottom;
            _borderAngle = Import._borderAngle;
            _borderBlend = Import._borderBlend;

            _hoverBackTop = Import._hoverBackTop;
            _hoverBackBottom = Import._hoverBackBottom;
            _clickBackTop = Import._clickBackTop;
            _clickBackBottom = Import._clickBackBottom;

            _backAngle = Import._backAngle;
            _backBlend = Import._backBlend;

            _blendRender = Import._blendRender;
            _curve = Import._curve;
        }

        /// <summary>
        /// Sets the blending for both border and background to their defaults
        /// </summary>
        public void DefaultBlending()
        {
            _borderBlend = null;

            _backBlend = new Blend
            {
                Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
                Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
            };
        }

        #endregion
    }

    #endregion

    #region "EasyRender -- Dropdown Button controlling class"
    /// <summary>
    /// 
    /// </summary>
    public class IDropDownButton : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IButton class for customization
        /// </summary>
        public IDropDownButton()
        {
            DefaultBlending();
        }

        /// <summary>
        /// Creates a new IButton class for customization
        /// </summary>
        /// <param name="Import">The IButton to import the settings from</param>
        public IDropDownButton(IDropDownButton Import)
        {
            DefaultBlending();

            Apply(Import);
        }

        /// <summary>
        /// Disposes of the IButton class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _borderTop = Color.FromArgb(157, 183, 217);
        private Color _borderBottom = Color.FromArgb(157, 183, 217);
        private Color _borderInner = Color.FromArgb(255, 247, 185);
        private Blend _borderBlend = null;
        private float _borderAngle = 90f;

        private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
        private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);

        private float _backAngle = 90f;
        private Blend _backBlend = null;

        private BlendRender _blendRender = BlendRender.Hover | BlendRender.Check;
        private int _curve = 1;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the Button background at the top, when hovered over
        /// </summary>
        public Color HoverBackgroundTop
        {
            get
            {
                return _hoverBackTop;
            }

            set
            {
                _hoverBackTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the bottom, when hovered over
        /// </summary>
        public Color HoverBackgroundBottom
        {
            get
            {
                return _hoverBackBottom;
            }

            set
            {
                _hoverBackBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button background
        /// If set to null, the Button will simply draw the gradient
        /// </summary>
        public Blend BackgroundBlend
        {
            get
            {
                return _backBlend;
            }

            set
            {
                _backBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button background will be drawn
        /// </summary>
        public float BackgroundAngle
        {
            get
            {
                return _backAngle;
            }

            set
            {
                _backAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the top
        /// </summary>
        public Color BorderTop
        {
            get
            {
                return _borderTop;
            }

            set
            {
                _borderTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the bottom
        /// </summary>
        public Color BorderBottom
        {
            get
            {
                return _borderBottom;
            }

            set
            {
                _borderBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button border
        /// If set to null, the Button will simply draw the border
        /// </summary>
        public Blend BorderBlend
        {
            get
            {
                return _borderBlend;
            }

            set
            {
                _borderBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button border will be drawn
        /// </summary>
        public float BorderAngle
        {
            get
            {
                return _borderAngle;
            }

            set
            {
                _borderAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the inside border
        /// </summary>
        public Color InnerBorder
        {
            get { return _borderInner; }
            set { _borderInner = value; }
        }

        /// <summary>
        /// Gets or sets when to apply the rendering ("Normal" and "Click" do not apply here)
        /// </summary>
        public BlendRender BlendOptions
        {
            get
            {
                return _blendRender;
            }

            set
            {
                _blendRender = value;
            }
        }

        /// <summary>
        /// Gets or sets the curve of the border of the Button
        /// </summary>
        public int Curve
        {
            get
            {
                return _curve;
            }

            set
            {
                _curve = value;
            }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IDropDownButton and applies it to the current
        /// </summary>
        /// <param name="Import">The IDropDownButton to import the settings from</param>
        public void Apply(IDropDownButton Import)
        {
            _borderTop = Import._borderTop;
            _borderBottom = Import._borderBottom;
            _borderAngle = Import._borderAngle;
            _borderBlend = Import._borderBlend;

            _hoverBackTop = Import._hoverBackTop;
            _hoverBackBottom = Import._hoverBackBottom;

            _backAngle = Import._backAngle;
            _backBlend = Import._backBlend;

            _blendRender = Import._blendRender;
            _curve = Import._curve;
        }

        /// <summary>
        /// Sets the blending for both border and background to their defaults
        /// </summary>
        public void DefaultBlending()
        {
            _borderBlend = null;

            _backBlend = new Blend
            {
                Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
                Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
            };
        }

        #endregion
    }

    #endregion

    #region "EasyRender -- Split Button controlling class"
    /// <summary>
    /// 
    /// </summary>
    public class ISplitButton : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new ISplitButton class for customization
        /// </summary>
        public ISplitButton()
        {
            DefaultBlending();
        }

        /// <summary>
        /// Disposes of the ISplitButton class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _borderTop = Color.FromArgb(157, 183, 217);
        private Color _borderBottom = Color.FromArgb(157, 183, 217);
        private Color _borderInner = Color.FromArgb(255, 247, 185);
        private Blend _borderBlend = null;
        private float _borderAngle = 90f;

        private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
        private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);

        private Color _clickBackTop = Color.FromArgb(245, 207, 57);
        private Color _clickBackBottom = Color.FromArgb(245, 225, 124);

        private float _backAngle = 90f;
        private Blend _backBlend = null;

        private ArrowDisplay _arrowDisplay = ArrowDisplay.Always;
        private Color _arrowColor = Color.Black;

        private BlendRender _blendRender = BlendRender.Hover | BlendRender.Click | BlendRender.Check;
        private int _curve = 1;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the Button background at the top, when hovered over
        /// </summary>
        public Color HoverBackgroundTop
        {
            get
            {
                return _hoverBackTop;
            }

            set
            {
                _hoverBackTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the bottom, when hovered over
        /// </summary>
        public Color HoverBackgroundBottom
        {
            get
            {
                return _hoverBackBottom;
            }

            set
            {
                _hoverBackBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the top, when clicked
        /// </summary>
        public Color ClickBackgroundTop
        {
            get
            {
                return _clickBackTop;
            }

            set
            {
                _clickBackTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button background at the bottom, when clicked
        /// </summary>
        public Color ClickBackgroundBottom
        {
            get
            {
                return _clickBackBottom;
            }

            set
            {
                _clickBackBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button background
        /// If set to null, the Button will simply draw the gradient
        /// </summary>
        public Blend BackgroundBlend
        {
            get
            {
                return _backBlend;
            }

            set
            {
                _backBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button background will be drawn
        /// </summary>
        public float BackgroundAngle
        {
            get
            {
                return _backAngle;
            }

            set
            {
                _backAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the top
        /// </summary>
        public Color BorderTop
        {
            get
            {
                return _borderTop;
            }

            set
            {
                _borderTop = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the Button border gradient from the bottom
        /// </summary>
        public Color BorderBottom
        {
            get
            {
                return _borderBottom;
            }

            set
            {
                _borderBottom = value;
            }
        }

        /// <summary>
        /// Gets or sets the blending that will occur when rendering the Button border
        /// If set to null, the Button will simply draw the border
        /// </summary>
        public Blend BorderBlend
        {
            get
            {
                return _borderBlend;
            }

            set
            {
                _borderBlend = value;
            }
        }

        /// <summary>
        /// Gets or sets the angle which the Button border will be drawn
        /// </summary>
        public float BorderAngle
        {
            get
            {
                return _borderAngle;
            }

            set
            {
                _borderAngle = value;
            }
        }

        /// <summary>
        /// Gets or sets the color of the inside border
        /// </summary>
        public Color InnerBorder
        {
            get { return _borderInner; }
            set { _borderInner = value; }
        }

        /// <summary>
        /// Gets or sets when to apply the rendering ("Normal" does not apply here)
        /// </summary>
        public BlendRender BlendOptions
        {
            get
            {
                return _blendRender;
            }

            set
            {
                _blendRender = value;
            }
        }

        /// <summary>
        /// Gets or sets the curve of the border of the Button
        /// </summary>
        public int Curve
        {
            get
            {
                return _curve;
            }

            set
            {
                _curve = value;
            }
        }

        /// <summary>
        /// Gets or sets when to display the drop-down arrow
        /// </summary>
        public ArrowDisplay ArrowDisplay
        {
            get { return _arrowDisplay; }
            set { _arrowDisplay = value; }
        }

        /// <summary>
        /// Gets or sets the color of the drop-down arrow
        /// </summary>
        public Color ArrowColor
        {
            get { return _arrowColor; }
            set { _arrowColor = value; }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined ISplitButton and applies it to the current
        /// </summary>
        /// <param name="Import">The ISplitButton to import the settings from</param>
        public void Apply(ISplitButton Import)
        {
            _borderTop = Import._borderTop;
            _borderBottom = Import._borderBottom;
            _borderAngle = Import._borderAngle;
            _borderBlend = Import._borderBlend;

            _hoverBackTop = Import._hoverBackTop;
            _hoverBackBottom = Import._hoverBackBottom;
            _clickBackTop = Import._clickBackTop;
            _clickBackBottom = Import._clickBackBottom;

            _backAngle = Import._backAngle;
            _backBlend = Import._backBlend;

            _blendRender = Import._blendRender;
            _curve = Import._curve;

            _arrowDisplay = Import._arrowDisplay;
            _arrowColor = Import._arrowColor;
        }

        /// <summary>
        /// Sets the blending for both border and background to their defaults
        /// </summary>
        public void DefaultBlending()
        {
            _borderBlend = null;

            _backBlend = new Blend
            {
                Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
                Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
            };
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Content and Panel controlling class"
    /// <summary>
    /// 
    /// </summary>
    public class IPanel : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IPanel class for customization
        /// </summary>
        public IPanel()
        {
        }

        /// <summary>
        /// Disposes of the IButton class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _cPanelTop = Color.FromArgb(191, 219, 255);
        private Color _cPanelBottom = Color.FromArgb(132, 171, 227);
        private float _cPanelAngle = 90f;
        private Blend _cPanelBlend = null;

        private SmoothingMode _mode = SmoothingMode.HighSpeed;

        private Boolean _panelsInherit = false;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the gradient at the top of the content panel
        /// </summary>
        public Color ContentPanelTop
        {
            get { return _cPanelTop; }
            set { _cPanelTop = value; }
        }

        /// <summary>
        /// Gets or sets the color of the gradient at the bottom of the content panel
        /// </summary>
        public Color ContentPanelBottom
        {
            get { return _cPanelBottom; }
            set { _cPanelBottom = value; }
        }

        /// <summary>
        /// Gets or sets whether each panel inherits the shading from the content panel
        /// </summary>
        public Boolean PanelInheritance
        {
            get { return _panelsInherit; }
            set { _panelsInherit = value; }
        }

        /// <summary>
        /// Gets or sets the angle which the background gradient is drawn
        /// </summary>
        public float BackgroundAngle
        {
            get { return _cPanelAngle; }
            set { _cPanelAngle = value; }
        }

        /// <summary>
        /// Gets or sets the blend of the background
        /// </summary>
        public Blend BackgroundBlend
        {
            get { return _cPanelBlend; }
            set { _cPanelBlend = value; }
        }

        /// <summary>
        /// Gets or sets a mode to render the background in
        /// </summary>
        public SmoothingMode Mode
        {
            get { return _mode; }
            set { _mode = value; }
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Status bar controlling class
    /// <summary>
    /// 
    /// </summary>
    public class IStatusBar : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IStatusBar class for customization
        /// </summary>
        public IStatusBar()
        {
            DefaultBlending();
        }

        /// <summary>
        /// Disposes of the IButton class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _backTop = Color.FromArgb(227, 239, 255);
        private Color _backBottom = Color.FromArgb(173, 209, 255);
        private Blend _backBlend = null;
        private float _backAngle = 90;

        private Color _borderDark = Color.FromArgb(86, 125, 176);
        private Color _borderLight = Color.White;
        //private Blend _borderBlend = null;
        //private float _borderAngle = 90;

        private Color _gripTop = Color.FromArgb(114, 152, 204);
        private Color _gripBottom = Color.FromArgb(248, 248, 248);
        private Int32 _gripSpacing = 4;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the gradient of the background at the top
        /// </summary>
        public Color BackgroundTop
        {
            get { return _backTop; }
            set { _backTop = value; }
        }

        /// <summary>
        /// Gets or sets the color of the gradient of the background at the bottom
        /// </summary>
        public Color BackgroundBottom
        {
            get { return _backBottom; }
            set { _backBottom = value; }
        }

        /// <summary>
        /// Gets or sets the blending that will apply to the background
        /// </summary>
        public Blend BackgroundBlend
        {
            get { return _backBlend; }
            set { _backBlend = value; }
        }

        /// <summary>
        /// Gets or sets the angle which the background gradient will be drawn
        /// </summary>
        public float BackgroundAngle
        {
            get { return _backAngle; }
            set { _backAngle = value; }
        }

        /// <summary>
        /// Gets or sets the color of the dark border
        /// </summary>
        public Color DarkBorder
        {
            get { return _borderDark; }
            set { _borderDark = value; }
        }

        /// <summary>
        /// Gets or sets the color of the light border
        /// </summary>
        public Color LightBorder
        {
            get { return _borderLight; }
            set { _borderLight = value; }
        }

        /// <summary>
        /// Gets or sets the color of the grip at the top-most
        /// </summary>
        public Color GripTop
        {
            get { return _gripTop; }
            set { _gripTop = value; }
        }

        /// <summary>
        /// Gets or sets the color of the grip at the bottom-most
        /// </summary>
        public Color GripBottom
        {
            get { return _gripBottom; }
            set { _gripBottom = value; }
        }

        /// <summary>
        /// Gets or sets the spacing of the grip blocks
        /// </summary>
        public Int32 GripSpacing
        {
            get { return _gripSpacing; }
            set { _gripSpacing = value; }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IStatusBar and applies it to the current
        /// </summary>
        /// <param name="Import">The IStatusBar to import the settings from</param>
        public void Apply(IStatusBar Import)
        {
            _borderDark = Import._borderDark;
            _borderLight = Import._borderLight;

            _backTop = Import._backTop;
            _backBottom = Import._backBottom;
            _backAngle = Import._backAngle;
            _backBlend = Import._backBlend;
        }

        /// <summary>
        /// Sets the blending for both border and background to their defaults
        /// </summary>
        public void DefaultBlending()
        {
            //_borderBlend = null;

            _backBlend = new Blend
            {
                Positions = new float[] { 0f, 0.25f, 0.25f, 0.57f, 0.86f, 1f },
                Factors = new float[] { 0.1f, 0.6f, 1f, 0.4f, 0f, 0.95f }
            };
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Menustrip controlling class"
    /// <summary>
    /// A class designed to be used in the EasyRender master control to customize the look and feel of the base Menustrip
    /// </summary>
    public class IMenustrip : IDisposable
    {
        #region "Initialization and Setup"

        /// <summary>
        /// Creates a new IToolstrip class for customization
        /// </summary>
        public IMenustrip()
        {
            _buttons = new IButton();

            DefaultBlending();
        }

        /// <summary>
        /// Creates a new IMenustrip class for customization
        /// </summary>
        /// <param name="Import">The IMenustrip to import the settings from</param>
        public IMenustrip(IMenustrip Import)
        {
            _buttons = new IButton();

            DefaultBlending();

            Apply(Import);
        }

        /// <summary>
        /// Disposes of the IMenustrip class and clears all resources related to it
        /// </summary>
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }

        #endregion

        #region "Private variables"

        private Color _menuBorderDark = Color.FromArgb(157, 183, 217);
        private Color _menuBorderLight = Color.Transparent;

        private InheritenceType _menuBackInh = InheritenceType.FromContentPanel;
        private Color _menuBackTop = Color.White;
        private Color _menuBackBottom = Color.White;
        private Blend _menuBackBlend = null;

        private Color _menuStripBtnBackground = Color.White;
        private Color _menuStripBtnBorder = Color.FromArgb(157, 183, 217);

        private IButton _buttons = null;

        private Color _marginLeft = Color.FromArgb(242, 255, 255);
        private Color _marginRight = Color.FromArgb(233, 238, 238);
        private Color _marginBorder = Color.FromArgb(197, 197, 197);

        private Color _sepDark = Color.FromArgb(197, 197, 197);
        private Color _sepLight = Color.FromArgb(254, 254, 254);
        private Int32 _sepInset = 30;

        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or sets the color of the menu-strip border (dark)
        /// </summary>
        public Color MenuBorderDark
        {
            get { return _menuBorderDark; }
            set { _menuBorderDark = value; }
        }

        /// <summary>
        /// Gets or sets the color of the menu-strip border (light)
        /// </summary>
        public Color MenuBorderLight
        {
            get { return _menuBorderLight; }
            set { _menuBorderLight = value; }
        }

        /// <summary>
        /// Gets or sets how the background of the menu-strip is inherited
        /// </summary>
        public InheritenceType BackgroundInheritence
        {
            get { return _menuBackInh; }
            set { _menuBackInh = value; }
        }

        /// <summary>
        /// If inheritence is set to none, the color of the background gradient at the top
        /// </summary>
        public Color BackgroundTop
        {
            get { return _menuBackTop; }
            set { _menuBackTop = value; }
        }

        /// <summary>
        /// If inheritence is set to none, the color of the background gradient at the bottom
        /// </summary>
        public Color BackgroundBottom
        {
            get { return _menuBackBottom; }
            set { _menuBackBottom = value; }
        }

        /// <summary>
        /// If inheritence is set to none, the blending option for the background
        /// </summary>
        public Blend BackgroundBlend
        {
            get { return _menuBackBlend; }
            set { _menuBackBlend = value; }
        }

        /// <summary>
        /// Gets or sets the color of the margin gradient at the left
        /// </summary>
        public Color MarginLeft
        {
            get { return _marginLeft; }
            set { _marginLeft = value; }
        }

        /// <summary>
        /// Gets or sets the color of the margin gradient at the right
        /// </summary>
        public Color MarginRight
        {
            get { return _marginRight; }
            set { _marginRight = value; }
        }

        /// <summary>
        /// Gets or sets the color of the margin border (displayed to the right)
        /// </summary>
        public Color MarginBorder
        {
            get { return _marginBorder; }
            set { _marginBorder = value; }
        }

        /// <summary>
        /// Gets or sets the color of the root menu-strip button background when it is selected
        /// </summary>
        public Color MenustripButtonBackground
        {
            get { return _menuStripBtnBackground; }
            set { _menuStripBtnBackground = value; }
        }

        /// <summary>
        /// Gets or sets the color of the root menu-strip button border when it is selected
        /// </summary>
        public Color MenustripButtonBorder
        {
            get { return _menuStripBtnBorder; }
            set { _menuStripBtnBorder = value; }
        }

        /// <summary>
        /// Gets or sets the color of the seperator dark color
        /// </summary>
        public Color SeperatorDark
        {
            get { return _sepDark; }
            set { _sepDark = value; }
        }

        /// <summary>
        /// Gets or sets the color of the seperator light color
        /// </summary>
        public Color SeperatorLight
        {
            get { return _sepLight; }
            set { _sepLight = value; }
        }

        /// <summary>
        /// Gets or sets the inset position of the seperator from the left
        /// </summary>
        public Int32 SeperatorInset
        {
            get { return _sepInset; }
            set { _sepInset = value; }
        }

        /// <summary>
        /// Gets the class that handles the look and feel of the menu-strip items
        /// </summary>
        [ReadOnly(true)]
        public IButton Items
        {
            get { return _buttons; }
        }

        #endregion

        #region "Methods"

        /// <summary>
        /// Imports the settings from a previous or pre-defined IMenustrip and applies it to the current
        /// </summary>
        /// <param name="Import">The IMenustrip to import the settings from</param>
        public void Apply(IMenustrip Import)
        {
            _menuBackInh = Import._menuBackInh;
            _menuBackTop = Import._menuBackTop;
            _menuBackBottom = Import._menuBackBottom;
            _menuBorderDark = Import._menuBorderDark;
            _menuBorderLight = Import._menuBorderLight;
            _menuBackBlend = Import._menuBackBlend;
            _buttons = Import._buttons;
        }

        /// <summary>
        /// Sets the blending for the background to it's default
        /// </summary>
        public void DefaultBlending()
        {
            _menuBackBlend = new Blend
            {
                Positions = new float[] { 0f, 0.3f, 0.5f, 0.8f, 1f },
                Factors = new float[] { 0f, 0f, 0f, 0.5f, 1f }
            };
        }

        #endregion
    }
    #endregion

    #region "EasyRender -- Enumerators"

    /// <summary>
    /// Defines when to show an arrow
    /// </summary>
    public enum ArrowDisplay
    {
        /// <summary>
        /// 
        /// </summary>
        Always,
        /// <summary>
        /// 
        /// </summary>
        Hover,
        /// <summary>
        /// 
        /// </summary>
        Never
    }

    /// <summary>
    /// Defines when to use a blend property
    /// </summary>
    public enum BlendRender
    {
        /// <summary>
        /// Use the blend when the object is drawn
        /// </summary>
        Normal,
        /// <summary>
        /// Use the blend when the object is hovered over
        /// </summary>
        Hover,
        /// <summary>
        /// Use the blend when the object is clicked
        /// </summary>
        Click,
        /// <summary>
        /// Use the blend when the object is checked
        /// </summary>
        Check,
        /// <summary>
        /// Always use the blend regardless of the state of the object
        /// </summary>
        All = Normal | Hover | Click | Check
    }

    /// <summary>
    /// Defines a method of drawing a grip on a control
    /// </summary>
    public enum GripType
    {
        /// <summary>
        /// Draws the grip as a set of dots
        /// </summary>
        Dotted,
        /// <summary>
        /// Draws the grip as two lines
        /// </summary>
        Lines,
        /// <summary>
        /// Does not draw the grip at all, but the object remains moveable
        /// </summary>
        None
    }

    /// <summary>
    /// Defines a specific type of button to search by
    /// </summary>
    public enum ButtonType
    {
        /// <summary>
        /// 
        /// </summary>
        NormalButton,
        /// <summary>
        /// 
        /// </summary>
        SplitButton,
        /// <summary>
        /// 
        /// </summary>
        MenuItem,
        /// <summary>
        /// 
        /// </summary>
        DropDownButton
    }

    /// <summary>
    /// Defines a method for background or object inheritence
    /// </summary>
    public enum InheritenceType
    {
        /// <summary>
        /// 
        /// </summary>
        FromContentPanel,
        /// <summary>
        /// 
        /// </summary>
        None
    }

    /// <summary>
    /// Defines a method of rendering
    /// </summary>
    public enum RenderingMode
    {
        /// <summary>
        /// 
        /// </summary>
        System,
        /// <summary>
        /// 
        /// </summary>
        Professional,
        /// <summary>
        /// 
        /// </summary>
        Custom
    }

    #endregion
}
