using System.Drawing;
using System.Drawing.Text;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using System.Diagnostics;

namespace TX.Framework.WindowUI.Controls
{
    /// <summary>
    /// Draw ToolStrips using the Office 2007 themed appearance.
    /// </summary>
    public class BseRenderer : ToolStripProfessionalRenderer
    {
        #region FieldsPrivate
        private static Rectangle[] baseSizeGripRectangles;
        private static int MarginInset;
        private static Blend MenuItemBlend;
        private static Blend ButtonBlend;
        #endregion

		#region MethodsPublic
		static BseRenderer()
        {
            MarginInset = 2;
            
            // One time creation of the blend for the button gradient brush
            ButtonBlend = new Blend();
            ButtonBlend.Positions = new float[] { 0.0F, 0.1F, 0.2F, 0.5F, 1.0F };
            ButtonBlend.Factors = new float[] { 0.6F, 0.7F, 0.8F, 1.0F, 1.0F };
            // One time creation of the blend for the menuitem gradient brush
            MenuItemBlend = new Blend();
            MenuItemBlend.Positions = new float[] { 0.0F, 0.1F, 0.2F, 0.5F, 1.0F };
            MenuItemBlend.Factors = new float[] { 0.7F, 0.8F, 0.9F, 1.0F, 1.0F };

            baseSizeGripRectangles = new Rectangle[] { new Rectangle(8, 0, 2, 2), new Rectangle(8, 4, 2, 2), new Rectangle(8, 8, 2, 2), new Rectangle(4, 4, 2, 2), new Rectangle(4, 8, 2, 2), new Rectangle(0, 8, 2, 2) };
        }
        /// <summary>
        /// Initialize a new instance of the BseRenderer class.
        /// </summary>
        public BseRenderer()
            : base(new TX.Framework.WindowUI.Controls.ColorTableBlack())
        {
			this.ColorTable.UseSystemColors = false;
		}
        /// <summary>
        /// Initializes a new instance of the BseRenderer class.
        /// </summary>
        /// <param name="professionalColorTable">A <see cref="TX.Framework.WindowUI.Controls.ProfessionalColorTable"/> to be used for painting.</param>
        public BseRenderer(ProfessionalColorTable professionalColorTable)
            : base(professionalColorTable)
        {
        }
        #endregion

		#region MethodsProtected
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.RenderArrow"/> event.
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripArrowRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderArrow(ToolStripArrowRenderEventArgs e)
        {
            if (ColorTable.UseSystemColors == true)
            {
                base.OnRenderArrow(e);
            }
            else
            {
                ProfessionalColorTable colorTable = ColorTable as TX.Framework.WindowUI.Controls.ProfessionalColorTable;
                if ((colorTable != null) && (e.Item.Enabled == true))
                {
                    if (e.Item.Owner is MenuStrip)
                    {
                        e.ArrowColor = colorTable.MenuItemText;
                    }
                    else if (e.Item.Owner is StatusStrip)
                    {
                        e.ArrowColor = colorTable.StatusStripText;
                    }
                    else
                    {
                        if (e.Item.Owner.GetType() != typeof(ToolStripDropDownMenu))
                        {
                            e.ArrowColor = colorTable.ToolStripText;
                        }
                    }
                }
                base.OnRenderArrow(e);
            }
        }
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.RenderButtonBackground"/> event.
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripItemRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (ColorTable.UseSystemColors == true)
            {
                base.OnRenderDropDownButtonBackground(e);
            }
            else
            {
                ToolStripButton item = e.Item as ToolStripButton;
                Rectangle buttonBounds = new Rectangle(Point.Empty, item.Size);
                if (IsZeroWidthOrHeight(buttonBounds) == true)
                {
                    return;
                }
                Graphics graphics = e.Graphics;
                ProfessionalColorTable colorTable = ColorTable as ProfessionalColorTable;
                if (colorTable != null)
                {
                    using (UseAntiAlias antiAlias = new UseAntiAlias(graphics))
                    {
                        Rectangle buttonRectangle = GetButtonRectangle(buttonBounds);

                        if (item.Checked == true)
                        {
                            //Draws the border of the button for the checked ToolStripButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.ButtonPressedBorder);
                        }
                        if ((item.Selected == true) && (item.Pressed == false))
                        {
                            //Renders the upper button part of the selected ToolStripButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Draws the border of the button for the selected ToolStripButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //DrawButtonBorder(graphics, buttonRectangle, Color.FromArgb(196, 194, 196));
                        }
                        if (item.Pressed == true)
                        {
                            //Renders the upper button part of the pressed ToolStripButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemPressedGradientBegin);
                            //Draws the inner border of the button for the pressed ToolStripButton control
                            DrawInnerButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //Draws the outer border of the button for the pressed ToolStripButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.MenuBorder);
                        }
                    }
                }
                else
                {
                    base.OnRenderDropDownButtonBackground(e);
                }
            }
        }
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.RenderDropDownButtonBackground"/> event.
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripItemRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (ColorTable.UseSystemColors == true)
            {
                base.OnRenderDropDownButtonBackground(e);
            }
            else
            {
                ToolStripDropDownButton item = e.Item as ToolStripDropDownButton;
                Rectangle buttonBounds = new Rectangle(Point.Empty, item.Size);
                if (IsZeroWidthOrHeight(buttonBounds) == true)
                {
                    return;
                }
                Graphics graphics = e.Graphics;
                ProfessionalColorTable colorTable = ColorTable as ProfessionalColorTable;

                if (colorTable != null)
                {
                    using (UseAntiAlias antiAlias = new UseAntiAlias(graphics))
                    {
                        Rectangle buttonRectangle = GetButtonRectangle(buttonBounds);
                        if ((item.Selected == true) && (item.Pressed == false))
                        {
                            //Renders the upper button part of the selected ToolStripDropDownButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Draws the border of the button for the selected ToolStripDropDownButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                        }
                        if (item.Pressed == true)
                        {
                            //Renders the upper button part of the pressed ToolStripDropDownButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemPressedGradientBegin);
                            //Draws the inner border of the button for the pressed ToolStripDropDownButton control
                            DrawInnerButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //Draws the outer border of the button for the pressed ToolStripDropDownButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.MenuBorder);
                        }
                    }
                }
                else
                {
                    base.OnRenderDropDownButtonBackground(e);
                }
            }
        }
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.OnRenderSplitButtonBackground"/> event.
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripItemRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (ColorTable.UseSystemColors == true)
            {
                base.OnRenderDropDownButtonBackground(e);
            }
            else
            {
                ToolStripSplitButton item = e.Item as ToolStripSplitButton;
                Rectangle buttonBounds = new Rectangle(Point.Empty, item.ButtonBounds.Size);
                if (IsZeroWidthOrHeight(buttonBounds) == true)
                {
                    return;
                }
                Graphics graphics = e.Graphics;
                ProfessionalColorTable colorTable = ColorTable as ProfessionalColorTable;
                if (colorTable != null)
                {
                    using (UseAntiAlias antiAlias = new UseAntiAlias(graphics))
                    {
                        Rectangle buttonRectangle = GetButtonRectangle(buttonBounds);
                        Rectangle dropDownButtonBounds = new Rectangle(item.DropDownButtonBounds.Location, item.DropDownButtonBounds.Size);
                        Rectangle dropDownButtonRectangle = GetButtonRectangle(dropDownButtonBounds);

                        if ((item.Selected == true) && (item.Pressed == false) && (item.ButtonPressed == false))
                        {
                            //Renders the upper button part of the selected ToolStripSplitButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Renders the dropDownButton part of the selected ToolStripSplitButton control
                            RenderButton(graphics, dropDownButtonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Draws the border of the button part for the selected ToolStripSplitButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //Draws the border of the dropDownButton part for the selected ToolStripSplitButton control
                            DrawButtonBorder(graphics, dropDownButtonRectangle, colorTable.ButtonSelectedHighlightBorder);
                        }
                        if (item.ButtonPressed == true)
                        {
                            //Renders the upper button part of the pressed ToolStripSplitButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemPressedGradientBegin);
                            //Renders the dropDownButton part of the pressed ToolStripSplitButton control
                            RenderButton(graphics, dropDownButtonRectangle, colorTable.MenuItemPressedGradientBegin);
                            //Draws the inner border of the button part for the pressed ToolStripSplitButton control
                            DrawInnerButtonBorder(graphics, buttonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //Draws the outer border of the button part for the pressed ToolStripSplitButton control
                            DrawButtonBorder(graphics, buttonRectangle, colorTable.MenuBorder);
                            //Draws the inner border of the dropDownButton part for the pressed ToolStripSplitButton control
                            DrawInnerButtonBorder(graphics, dropDownButtonRectangle, colorTable.ButtonSelectedHighlightBorder);
                            //Draws the outer border of the dropDownButton part for the pressed ToolStripSplitButton control
                            DrawButtonBorder(graphics, dropDownButtonRectangle, colorTable.MenuBorder);
                        }
                        if (item.DropDownButtonPressed == true)
                        {
                            //Renders the upper button part of the pressed ToolStripSplitButton control
                            RenderButton(graphics, buttonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Renders the dropDownButton part of the pressed ToolStripSplitButton control
                            RenderButton(graphics, dropDownButtonRectangle, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            //Draws the border of the button part for the pressed ToolStripSplitButton control
                            DrawButtonBorder(graphics, buttonRectangle, ColorTable.ButtonSelectedHighlightBorder);
                            //Draws the border of the dropDownButton part for the pressed ToolStripSplitButton control
                            DrawButtonBorder(graphics, dropDownButtonRectangle, ColorTable.ButtonSelectedHighlightBorder);
                        }
                        if (e.Item.Owner is MenuStrip)
                        {
                            base.DrawArrow(new ToolStripArrowRenderEventArgs(graphics, item, dropDownButtonBounds, colorTable.MenuItemText, ArrowDirection.Down));
                        }
                        if (e.Item.Owner is StatusStrip)
                        {
                            base.DrawArrow(new ToolStripArrowRenderEventArgs(graphics, item, dropDownButtonBounds, colorTable.StatusStripText, ArrowDirection.Down));
                        }
                        if (e.Item.Owner is ToolStrip)
                        {
                            base.DrawArrow(new ToolStripArrowRenderEventArgs(graphics, item, dropDownButtonBounds, colorTable.ToolStripText, ArrowDirection.Down));
                        }
                    }
                }
                else
                {
                    base.OnRenderDropDownButtonBackground(e);
                }
            }
        }
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.RenderMenuItemBackground"/> event. 
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripItemRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e)
        {
            ToolStripMenuItem item = e.Item as ToolStripMenuItem;
            Rectangle bounds = new Rectangle(Point.Empty, item.Size);
            if (IsZeroWidthOrHeight(bounds) == true)
            {
                return;
            }
            Graphics graphics = e.Graphics;
            ProfessionalColorTable colorTable = ColorTable as TX.Framework.WindowUI.Controls.ProfessionalColorTable;
            if (colorTable != null)
            {
                using (UseAntiAlias useAntiAlias = new UseAntiAlias(graphics))
                {
                    if (e.ToolStrip is MenuStrip)
                    {
                        if ((item.Selected == true) && (item.Pressed == false))
                        {
                            RenderMenuItem(graphics, bounds, colorTable.MenuItemTopLevelSelectedGradientBegin);
                            ControlPaint.DrawBorder(e.Graphics, bounds, colorTable.MenuItemTopLevelSelectedBorder, ButtonBorderStyle.Solid);
                        }
                        if (item.Pressed == true)
                        {
                            RenderButton(graphics, bounds, ColorTable.MenuItemPressedGradientBegin);
                            Rectangle innerBorderRectangle = bounds;
                            innerBorderRectangle.Inflate(-1, -1);
                            ControlPaint.DrawBorder(e.Graphics, innerBorderRectangle, ColorTable.ButtonSelectedHighlightBorder, ButtonBorderStyle.Solid);
                            ControlPaint.DrawBorder(e.Graphics, bounds, ColorTable.MenuBorder, ButtonBorderStyle.Solid);
                        }
                    }
                    else
                    {
                        base.OnRenderMenuItemBackground(e);
                    }
                }
            }
            else
            {
                base.OnRenderMenuItemBackground(e);
            }
        }
        /// <summary>
        /// Raises the RenderItemText event.
        /// </summary>
        /// <param name="e">A ToolStripItemTextRenderEventArgs that contains the event data.</param>
        protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e)
        {
			if (ColorTable.UseSystemColors == false)
			{
				ProfessionalColorTable colorTable = ColorTable as TX.Framework.WindowUI.Controls.ProfessionalColorTable;
				if (colorTable != null)
				{
                    if ((e.ToolStrip is MenuStrip))// && (e.Item.Selected == false) && e.Item.Pressed == false)
                    {
                        if (colorTable.MenuItemText != Color.Empty)
                        {
                            e.TextColor = colorTable.MenuItemText;
                        }
                    }
                    else if ((e.ToolStrip is StatusStrip))// && (e.Item.Selected == false) && e.Item.Pressed == false)
                    {
                        if (colorTable.StatusStripText != Color.Empty)
                        {
                            e.TextColor = colorTable.StatusStripText;
                        }
                    }
                    else if (e.ToolStrip is ToolStripDropDown)
                    {
                        //base.OnRenderItemText(e);
                    }
                    else
                    {
                        if (colorTable.ToolStripText != Color.Empty)
                        {
                            e.TextColor = colorTable.ToolStripText;
                        }
                    }
				}
			}
            base.OnRenderItemText(e);
        }
        /// <summary>
        /// Raises the RenderToolStripContentPanelBackground event. 
        /// </summary>
        /// <param name="e">An ToolStripContentPanelRenderEventArgs containing the event data.</param>
        protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e)
        {
            // Must call base class, otherwise the subsequent drawing does not appear!
            base.OnRenderToolStripContentPanelBackground(e);
			if (ColorTable.UseSystemColors == false)
			{
				// Cannot paint a zero sized area
				if ((e.ToolStripContentPanel.Width > 0) &&
					(e.ToolStripContentPanel.Height > 0))
				{
					using (LinearGradientBrush backBrush = new LinearGradientBrush(e.ToolStripContentPanel.ClientRectangle,
																				   ColorTable.ToolStripContentPanelGradientBegin,
																				   ColorTable.ToolStripContentPanelGradientEnd,
																				   LinearGradientMode.Vertical))
					{
						e.Graphics.FillRectangle(backBrush, e.ToolStripContentPanel.ClientRectangle);
					}
				}
			}
        }
        /// <summary>
        /// Raises the <see cref="System.Windows.Forms.ToolStripRenderer.RenderOverflowButtonBackground"/> event.
        /// </summary>
        /// <param name="e">A <see cref="System.Windows.Forms.ToolStripItemRenderEventArgs"/> that contains the event data.</param>
        protected override void OnRenderOverflowButtonBackground(ToolStripItemRenderEventArgs e)
        {
            base.OnRenderOverflowButtonBackground(e);
            ToolStripItem item = e.Item;
            if ((item.Selected == false) && (item.Pressed == false))
            {
                ProfessionalColorTable colorTable = ColorTable as ProfessionalColorTable;
                if (colorTable != null)
                {
                    Graphics graphics = e.Graphics;
                    bool bRightToLeft = item.RightToLeft == RightToLeft.Yes;

                    bool bOrientation = e.ToolStrip.Orientation == Orientation.Horizontal;
                    Rectangle arrowRectangle = Rectangle.Empty;
                    if (bRightToLeft)
                    {
                        arrowRectangle = new Rectangle(0, item.Height - 8, 9, 5);
                    }
                    else
                    {
                        arrowRectangle = new Rectangle(item.Width - 12, item.Height - 8, 9, 5);
                    }

                    ArrowDirection arrowDirection = bOrientation ? ArrowDirection.Down : ArrowDirection.Right;
                    int x = (bRightToLeft && bOrientation) ? -1 : 1;
                    arrowRectangle.Offset(x, 1);
                    RenderArrowInternal(graphics, arrowRectangle, arrowDirection, colorTable.ToolStripGradientMiddle);
                    arrowRectangle.Offset(-1 * x, -1);
                    RenderArrowInternal(graphics, arrowRectangle, arrowDirection, colorTable.ToolStripText);
                    if (bOrientation)
                    {
                        x = bRightToLeft ? -2 : 0;
                        RenderOverflowButtonLine(graphics, colorTable.ToolStripText, (int)(arrowRectangle.Right - 6), (int)(arrowRectangle.Y - 2), (int)(arrowRectangle.Right - 2), (int)(arrowRectangle.Y - 2));
                        RenderOverflowButtonLine(graphics, colorTable.ToolStripGradientMiddle, (int)((arrowRectangle.Right - 5) + x), (int)(arrowRectangle.Y - 1), (int)((arrowRectangle.Right - 1) + x), (int)(arrowRectangle.Y - 1));
                    }
                    else
                    {
                        RenderOverflowButtonLine(graphics, colorTable.ToolStripText, arrowRectangle.X, arrowRectangle.Y, arrowRectangle.X, arrowRectangle.Bottom - 1);
                        RenderOverflowButtonLine(graphics, colorTable.ToolStripGradientMiddle, arrowRectangle.X + 1, arrowRectangle.Y + 1, arrowRectangle.X + 1, arrowRectangle.Bottom);
                    }
                }
            }
        }
        /// <summary>
        /// Raises the RenderSeparator event. 
        /// </summary>
        /// <param name="e">An ToolStripSeparatorRenderEventArgs containing the event data.</param>
        protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e)
        {
			if (ColorTable.UseSystemColors == false)
			{
				e.Item.ForeColor = ColorTable.RaftingContainerGradientBegin;
			}
            base.OnRenderSeparator(e);
        }
        /// <summary>
        /// Raises the RenderStatusStripSizingGrip event.
        /// </summary>
        /// <param name="e">A ToolStripRenderEventArgs that contains the event data.</param>
        protected override void OnRenderStatusStripSizingGrip(ToolStripRenderEventArgs e)
        {
            Graphics graphics = e.Graphics;
            StatusStrip toolStrip = e.ToolStrip as StatusStrip;
            if (toolStrip != null)
            {
                Rectangle sizeGripBounds = toolStrip.SizeGripBounds;
                if (IsZeroWidthOrHeight(sizeGripBounds) == false)
                {
                    Rectangle[] rectanglesLight = new Rectangle[baseSizeGripRectangles.Length];
                    Rectangle[] rectanglesDark = new Rectangle[baseSizeGripRectangles.Length];
                    for (int i = 0; i < baseSizeGripRectangles.Length; i++)
                    {
                        Rectangle rectangleDark = baseSizeGripRectangles[i];
                        if (toolStrip.RightToLeft == RightToLeft.Yes)
                        {
                            rectangleDark.X = (sizeGripBounds.Width - rectangleDark.X) - rectangleDark.Width;
                        }
                        rectangleDark.Offset(sizeGripBounds.X, sizeGripBounds.Bottom - 12);
                        rectanglesLight[i] = rectangleDark;
                        if (toolStrip.RightToLeft == RightToLeft.Yes)
                        {
                            rectangleDark.Offset(1, -1);
                        }
                        else
                        {
                            rectangleDark.Offset(-1, -1);
                        }
                        rectanglesDark[i] = rectangleDark;
                    }
                    using (SolidBrush darkBrush = new SolidBrush(ColorTable.GripDark),
                        lightBrush = new SolidBrush(ColorTable.GripDark))
                    {
                        graphics.FillRectangles(lightBrush, rectanglesLight);
                        graphics.FillRectangles(darkBrush, rectanglesDark);
                    }
                }
            }
        }
        /// <summary>
        /// Raises the RenderToolStripBackground event. 
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
        {
            if (ColorTable.UseSystemColors == true)
            {
                base.OnRenderToolStripBackground(e);
            }
            else
            {
                Trace.WriteLine("ToolStrip: " + e.ToolStrip.GetType());
                Rectangle backgroundRectangle = new Rectangle(0, 0, e.ToolStrip.Width, e.ToolStrip.Height);
                Rectangle innerRectangle = backgroundRectangle;
                innerRectangle.Height = (backgroundRectangle.Height / 2) + 1;
                // Cannot paint a zero sized area
                if ((backgroundRectangle.Width > 0) && (backgroundRectangle.Height > 0))
                {
                    if (e.ToolStrip is StatusStrip)
                    {
                        using (SolidBrush outerBrush = new SolidBrush(ColorTable.StatusStripGradientEnd))
                        {
                            e.Graphics.FillRectangle(outerBrush, backgroundRectangle);
                        }

                        int y2 = backgroundRectangle.Height / 2;
                        Rectangle upperRectangle = new Rectangle(backgroundRectangle.X, backgroundRectangle.Y, backgroundRectangle.Width, y2);
                        upperRectangle.Height += 1;
                        using (LinearGradientBrush innerRectangleBrush = new LinearGradientBrush(
                            upperRectangle,
                            ColorTable.StatusStripGradientBegin,
                            Color.FromArgb(128,ColorTable.StatusStripGradientBegin),
                            LinearGradientMode.Vertical))
                        {
                            e.Graphics.FillRectangle(innerRectangleBrush, upperRectangle); //draw top bubble
                        }

                        y2 = (backgroundRectangle.Height / 4) + 1;
                        Rectangle lowerRectangle = new Rectangle(backgroundRectangle.X, backgroundRectangle.Height - y2, backgroundRectangle.Width, y2);

                        using (LinearGradientBrush innerRectangleBrush = new LinearGradientBrush(
                            lowerRectangle,
                            ColorTable.StatusStripGradientEnd,
                            Color.FromArgb(128,ColorTable.StatusStripGradientBegin),
                            LinearGradientMode.Vertical))
                        {
                            e.Graphics.FillRectangle(innerRectangleBrush, lowerRectangle); //draw top bubble
                        }
                    }
                    else if (e.ToolStrip is MenuStrip)
                    {
                        using (SolidBrush outerBrush = new SolidBrush(ColorTable.MenuStripGradientEnd))
                        {
                            e.Graphics.FillRectangle(outerBrush, backgroundRectangle);
                        }

                        int y2 = backgroundRectangle.Height / 3;
                        Rectangle lowerRectangle = new Rectangle(backgroundRectangle.X, backgroundRectangle.Y, backgroundRectangle.Width, y2);

                        using (LinearGradientBrush innerRectangleBrush = new LinearGradientBrush(
                            lowerRectangle,
                            ColorTable.MenuStripGradientBegin,
                            Color.FromArgb(128, ColorTable.StatusStripGradientBegin),
                            LinearGradientMode.Vertical))
                        {
                            e.Graphics.FillRectangle(innerRectangleBrush, lowerRectangle); //draw top bubble
                        }
                    }
                    else if (e.ToolStrip is ToolStripDropDown)
                    {
                        base.OnRenderToolStripBackground(e);
                    }
                    else
                    {
                        using (SolidBrush outerBrush = new SolidBrush(ColorTable.ToolStripGradientEnd))
                        {
                            e.Graphics.FillRectangle(outerBrush, backgroundRectangle);
                        }

                        int y2 = backgroundRectangle.Height / 2;
                        Rectangle upperRectangle = new Rectangle(backgroundRectangle.X, backgroundRectangle.Y, backgroundRectangle.Width, y2);

                        using (LinearGradientBrush innerRectangleBrush = new LinearGradientBrush(
                            upperRectangle,
                            ColorTable.ToolStripGradientBegin,
                            ColorTable.ToolStripGradientMiddle,
                            LinearGradientMode.Vertical))
                        {
                            e.Graphics.FillRectangle(innerRectangleBrush, upperRectangle); //draw top bubble
                        }

                        y2 = backgroundRectangle.Height / 4; 
                        Rectangle lowerRectangle = new Rectangle(backgroundRectangle.X, backgroundRectangle.Height - y2, backgroundRectangle.Width, y2);

                        using (LinearGradientBrush innerRectangleBrush = new LinearGradientBrush(
                            lowerRectangle,
                            ColorTable.ToolStripGradientEnd,
                            ColorTable.ToolStripGradientMiddle,
                            LinearGradientMode.Vertical))
                        {
                            e.Graphics.FillRectangle(innerRectangleBrush, lowerRectangle); //draw top bubble
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Raises the RenderImageMargin event. 
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderImageMargin(ToolStripRenderEventArgs e)
        {
			if (ColorTable.UseSystemColors == true)
			{
				base.OnRenderToolStripBackground(e);
			}
			else
			{
				if ((e.ToolStrip is ContextMenuStrip) ||
					(e.ToolStrip is ToolStripDropDownMenu))
				{
					// Start with the total margin area
					Rectangle marginRectangle = e.AffectedBounds;

					// Do we need to draw with separator on the opposite edge?
					bool bIsRightToLeft = (e.ToolStrip.RightToLeft == RightToLeft.Yes);

					marginRectangle.Y += MarginInset;
					marginRectangle.Height -= MarginInset * 2;

					// Reduce so it is inside the border
					if (bIsRightToLeft == false)
					{
						marginRectangle.X += MarginInset;
					}
					else
					{
						marginRectangle.X += MarginInset / 2;
					}

					// Draw the entire margine area in a solid color
					using (SolidBrush backBrush = new SolidBrush(
						ColorTable.ImageMarginGradientBegin))
						e.Graphics.FillRectangle(backBrush, marginRectangle);
				}
				else
				{
					base.OnRenderImageMargin(e);
				}
			}
        }

		#endregion

		#region MethodsPrivate
        private static GraphicsPath GetBackgroundPath(Rectangle bounds, int radius)
        {
            int x = bounds.X;
            int y = bounds.Y;
            int width = bounds.Width;
            int height = bounds.Height;
            GraphicsPath graphicsPath = new GraphicsPath();
            graphicsPath.AddArc(x, y, radius, radius, 180, 90);				                    //Upper left corner
            graphicsPath.AddArc(x + width - radius, y, radius, radius, 270, 90);			    //Upper right corner
            graphicsPath.AddArc(x + width - radius, y + height - radius, radius, radius, 0, 90);//Lower right corner
            graphicsPath.AddArc(x, y + height - radius, radius, radius, 90, 90);			    //Lower left corner
            graphicsPath.CloseFigure();
            return graphicsPath;
        }

        private static void RenderButton(Graphics graphics, Rectangle buttonBounds, Color gradientColor)
        {
            using (GraphicsPath graphicsPath = GetBackgroundPath(buttonBounds, 3))
            {
                using (LinearGradientBrush backBrush = new LinearGradientBrush(buttonBounds,
                    gradientColor,
                    Color.Transparent,
                    LinearGradientMode.Vertical))
                {
                    backBrush.Blend = ButtonBlend;
                    graphics.FillPath(backBrush, graphicsPath);
                }
            }
        }

        private static void RenderMenuItem(Graphics graphics, Rectangle menuBounds, Color gradientColor)
        {
            using (LinearGradientBrush backBrush = new LinearGradientBrush(
                menuBounds,
                gradientColor,
                Color.Transparent,
                LinearGradientMode.Vertical))
            {
                backBrush.Blend = MenuItemBlend;
                graphics.FillRectangle(backBrush, menuBounds);
            }
        }

        private static void DrawButtonBorder(Graphics graphics, Rectangle buttonBounds, Color borderColor)
        {
            using (GraphicsPath itemPath = GetBackgroundPath(buttonBounds, 3))
            {
                using (Pen itemPen = new Pen(borderColor))
                {
                    graphics.DrawPath(itemPen, itemPath);
                }
            }
        }

        private static void DrawInnerButtonBorder(Graphics graphics, Rectangle buttonBounds, Color innerBorderColor)
        {
            Rectangle innerButtonRectangle = buttonBounds;
            innerButtonRectangle.Height -= 1;
            innerButtonRectangle.Width -= 1;
            using (GraphicsPath innerBorderPath = GetBackgroundPath(innerButtonRectangle, 3))
            {
                using (Pen itemPen = new Pen(innerBorderColor))
                {
                    graphics.DrawPath(itemPen, innerBorderPath);
                }
            }
        }

        private static Rectangle GetButtonRectangle(Rectangle bounds)
        {
            Rectangle buttonRectangle = bounds;
            buttonRectangle.Width -= 1;
            buttonRectangle.Height -= 1;
            buttonRectangle.Inflate(0, -1);
            return buttonRectangle;
        }
        /// <summary>
        /// Renders the arrows in the OverflowButton.
        /// </summary>
        /// <param name="graphics">The Graphics to draw on.</param>
        /// <param name="dropDownRectangle">The rectangle in which the arrows should drawn.</param>
        /// <param name="direction">the direction of the arrows.</param>
        /// <param name="color">The color used to fill the arrow polygons</param>
        private static void RenderArrowInternal(Graphics graphics, Rectangle dropDownRectangle, ArrowDirection direction, Color color)
        {
            Point point = new Point(dropDownRectangle.Left + (dropDownRectangle.Width / 2), dropDownRectangle.Top + (dropDownRectangle.Height / 2));
            point.X += dropDownRectangle.Width % 2;
            Point[] points = null;
            switch (direction)
            {
                case ArrowDirection.Left:
                    points = new Point[] { new Point(point.X + 2, point.Y - 3), new Point(point.X + 2, point.Y + 3), new Point(point.X - 1, point.Y) };
                    break;

                case ArrowDirection.Up:
                    points = new Point[] { new Point(point.X - 2, point.Y + 1), new Point(point.X + 3, point.Y + 1), new Point(point.X, point.Y - 2) };
                    break;

                case ArrowDirection.Right:
                    points = new Point[] { new Point(point.X - 2, point.Y - 3), new Point(point.X - 2, point.Y + 3), new Point(point.X + 1, point.Y) };
                    break;

                default:
                    points = new Point[] { new Point(point.X - 2, point.Y - 1), new Point(point.X + 3, point.Y - 1), new Point(point.X, point.Y + 2) };
                    break;
            }
            using (SolidBrush backBrush = new SolidBrush(color))
            {
                graphics.FillPolygon(backBrush, points);
            }
        }
        /// <summary>
        /// Renders the lines in the OverflowButton.
        /// </summary>
        /// <param name="graphics">The Graphics to draw on.</param>
        /// <param name="color">The color used to fill the line</param>
        /// <param name="x1">The x-coordinate of the first point.</param>
        /// <param name="y1">The y-coordinate of the first point.</param>
        /// <param name="x2">The x-coordinate of the second point.</param>
        /// <param name="y2">The y-coordinate of the second point.</param>
        private static void RenderOverflowButtonLine(Graphics graphics,Color color, int x1, int y1, int x2, int y2)
        {
            using (Pen pen = new Pen(color))
            {
                graphics.DrawLine(pen, x1, y1, x2, y2);
            }
        }
        /// <summary>
        /// Checks if the rectangle width or height is equal to 0.
        /// </summary>
        /// <param name="rectangle">the rectangle to check</param>
        /// <returns>true if the with or height of the rectangle is 0 else false</returns>
        private static bool IsZeroWidthOrHeight(Rectangle rectangle)
        {
            if (rectangle.Width != 0)
            {
                return (rectangle.Height == 0);
            }
            return true;
        }
        #endregion
    }
}
