using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;

#if TREEGX
namespace DevComponents.Tree
#elif DOTNETBAR
namespace DevComponents.DotNetBar
#endif
{
	/// <summary>
	/// Paints the ElementStyle
	/// </summary>
	public class ElementStyleDisplay
	{
		/// <summary>Creates new instance of the object.</summary>
		public ElementStyleDisplay()
		{
		}

        /// <summary>
        /// Paints text for given style.
        /// </summary>
        /// <param name="e">Display information.</param>
        /// <param name="text">Text to paint.</param>
        /// <param name="defaultFont">Default font if no font by style is specified.</param>
        public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont)
        {
            PaintText(e, text, defaultFont, false);
        }

		/// <summary>
        /// Paints text for given style.
		/// </summary>
        /// <param name="e">Display information.</param>
        /// <param name="text"><Text to paint./param>
        /// <param name="defaultFont">Default font if no font by style is specified.</param>
		/// <param name="useDefaultFont">Specifies whether to use default font for painting regardless of style settings.</param>
		public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont, bool useDefaultFont)
		{
            PaintText(e, text, defaultFont, useDefaultFont, e.Style.TextFormat);
		}

        /// <summary>
        /// Paints text for given style.
        /// </summary>
        /// <param name="e">Display information.</param>
        /// <param name="text"><Text to paint./param>
        /// <param name="defaultFont">Default font if no font by style is specified.</param>
        /// <param name="useDefaultFont">Specifies whether to use default font for painting regardless of style settings.</param>
        public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont, bool useDefaultFont, eTextFormat textFormat)
        {
            Rectangle textBounds = e.Bounds;
            ElementStyle style = GetElementStyle(e.Style);

            if (text == "" || textBounds.IsEmpty || style.TextColor.IsEmpty)
                return;

            Font font = style.Font;
            if (font == null || useDefaultFont)
                font = defaultFont;

            textBounds.X += style.MarginLeft;
            textBounds.Width -= (style.MarginLeft + style.MarginRight);
            textBounds.Y += style.MarginTop;
            textBounds.Height -= (style.MarginTop + style.MarginBottom);

            if (!style.TextShadowColor.IsEmpty && Math.Abs(style.TextShadowColor.GetBrightness() - style.TextColor.GetBrightness()) > .2)
            {
                using (SolidBrush brush = new SolidBrush(style.TextShadowColor))
                {
                    Rectangle r = textBounds;
                    r.Offset(style.TextShadowOffset);
                    TextDrawing.DrawString(e.Graphics, text, font, style.TextShadowColor, r, textFormat);
                    //e.Graphics.DrawString(text,font,brush,r,style.StringFormat);
                }
            }

            if (!style.TextColor.IsEmpty)
                TextDrawing.DrawString(e.Graphics, text, font, style.TextColor, textBounds, textFormat);
        }

		/// <summary>Returns new Region object for given ElementStyle.</summary>
		/// <returns>New instance of Region object.</returns>
		/// <param name="e">Information to describe ElementStyle.</param>
		public static Region GetStyleRegion(ElementStyleDisplayInfo e)
		{
            Rectangle rectPath = e.Bounds;
            if (e.Style.PaintBorder && e.Style.CornerType!=eCornerType.Square)
            {
                rectPath.Width--;
                rectPath.Height--;
            }

            GraphicsPath path = ElementStyleDisplay.GetBackgroundPath(e.Style, rectPath);
            Region r = new Region();
            r.MakeEmpty();
            r.Union(path);
            // Widen path for the border...
            if (e.Style.PaintBorder && (e.Style.CornerType == eCornerType.Rounded || e.Style.CornerType == eCornerType.Diagonal || 
                e.Style.CornerTypeTopLeft == eCornerType.Rounded || e.Style.CornerTypeTopLeft == eCornerType.Diagonal ||
                e.Style.CornerTypeTopRight==eCornerType.Rounded || e.Style.CornerTypeTopRight==eCornerType.Diagonal ||
                e.Style.CornerTypeBottomLeft==eCornerType.Rounded || e.Style.CornerTypeBottomLeft==eCornerType.Diagonal ||
                e.Style.CornerTypeBottomRight==eCornerType.Rounded || e.Style.CornerTypeBottomRight==eCornerType.Diagonal))
            {
                using (Pen pen = new Pen(Color.Black, (e.Style.BorderTopWidth>0?e.Style.BorderTopWidth:1)))
                {
                    path.Widen(pen);
                }
                //Region r2 = new Region(path);
                r.Union(path);
            }

            return r;
            //GraphicsPath path=ElementStyleDisplay.GetBackgroundPath(e.Style,e.Bounds,false);
            //return new Region(path);
		}

        /// <summary>
        /// Returns the clipping for the content of the element style.
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public static GraphicsPath GetInsideClip(ElementStyleDisplayInfo e)
        {
            Rectangle rectPath = e.Bounds;
            // GDI bug
            if (e.Style.PaintBorder)
            {
                if (e.Style.PaintTopBorder)
                {
                    rectPath.Y += e.Style.BorderTopWidth;
                    rectPath.Height -= e.Style.BorderTopWidth;

                    if (e.Style.BorderTop == eStyleBorderType.Etched || e.Style.BorderTop == eStyleBorderType.Double)
                    {
                        rectPath.Y += e.Style.BorderTopWidth;
                        rectPath.Height -= e.Style.BorderTopWidth;
                    }
                }

                if (e.Style.PaintBottomBorder)
                {
                    rectPath.Height -= e.Style.BorderBottomWidth;
                    if (e.Style.BorderBottom == eStyleBorderType.Etched || e.Style.BorderBottom == eStyleBorderType.Double)
                        rectPath.Height -= e.Style.BorderBottomWidth;
                }

                if (e.Style.PaintLeftBorder)
                {
                    rectPath.X += e.Style.BorderLeftWidth;
                    rectPath.Width -= e.Style.BorderLeftWidth;
                    if (e.Style.BorderLeft == eStyleBorderType.Etched || e.Style.BorderLeft == eStyleBorderType.Double)
                    {
                        rectPath.X += e.Style.BorderLeftWidth;
                        rectPath.Width -= e.Style.BorderLeftWidth;
                    }
                }

                if (e.Style.PaintRightBorder)
                {
                    rectPath.Width -= e.Style.BorderRightWidth;
                    if (e.Style.BorderRight == eStyleBorderType.Etched || e.Style.BorderRight == eStyleBorderType.Double)
                        rectPath.Width -= e.Style.BorderRightWidth;
                }
            }

            GraphicsPath path = ElementStyleDisplay.GetBackgroundPath(e.Style, rectPath);

            return path;
        }

		/// <summary>
		/// Paints the element style on the canvas.
		/// </summary>
		/// <param name="e">Holds information neccessary to paint style on canvas.</param>
		public static void Paint(ElementStyleDisplayInfo e)
		{
			ElementStyleDisplay.PaintBackground(e);
			ElementStyleDisplay.PaintBackgroundImage(e);
			ElementStyleDisplay.PaintBorder(e);
		}

		private static eCornerType GetCornerType(eCornerType baseType, eCornerType specificType)
		{
			if(specificType!=eCornerType.Inherit)
				return specificType;
			return baseType;
		}

		/// <summary>
		/// Paint style border.
		/// </summary>
		/// <param name="e">Style display information.</param>
		public static void PaintBorder(ElementStyleDisplayInfo e)
		{
            ElementStyle style = GetElementStyle(e.Style);
			Rectangle bounds=ElementStyleDisplay.GetBorderRectangle(style,e.Bounds);
            if (bounds.Width < 2 || bounds.Height < 2)
                return;

            eCornerType cornerTopLeft = GetCornerType(style.CornerType, style.CornerTypeTopLeft);
            eCornerType cornerTopRight = GetCornerType(style.CornerType, style.CornerTypeTopRight);
            eCornerType cornerBottomLeft = GetCornerType(style.CornerType, style.CornerTypeBottomLeft);
            eCornerType cornerBottomRight = GetCornerType(style.CornerType, style.CornerTypeBottomRight);

            if (!style.BorderColor2.IsEmpty || !style.BorderColorLight.IsEmpty)
            {
                if (style.Border == eStyleBorderType.Solid)
                {
                    using (GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(bounds, style.CornerDiameter, eStyleBackgroundPathPart.Complete,
                        cornerTopLeft, cornerTopRight, cornerBottomLeft, cornerBottomRight))
                    {
                        DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColor, style.BorderColor2, style.BorderGradientAngle, style.BorderWidth);
                    }
                    return;
                }
                else if (style.Border == eStyleBorderType.Etched)
                {
                    Rectangle r = bounds;
                    
                    r.Width -= style.BorderWidth;
                    r.Height -= style.BorderWidth;
                    r.Offset(style.BorderWidth, style.BorderWidth);
                    if (r.Width > 2 && r.Height > 2)
                    {
                        using (GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(r, style.CornerDiameter, eStyleBackgroundPathPart.Complete,
                            cornerTopLeft, cornerTopRight, cornerBottomLeft, cornerBottomRight))
                        {
                            DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColorLight, style.BorderColorLight2, style.BorderLightGradientAngle, style.BorderWidth);
                        }
                        r.Offset(-style.BorderWidth, -style.BorderWidth);
                        using (GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(r, style.CornerDiameter, eStyleBackgroundPathPart.Complete,
                            cornerTopLeft, cornerTopRight, cornerBottomLeft, cornerBottomRight))
                        {
                            DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColor, style.BorderColor2, style.BorderGradientAngle, style.BorderWidth);
                        }
                    }
                    return;
                }
                else if ((style.BorderTop == eStyleBorderType.Double && style.BorderLeft == eStyleBorderType.Double &&
                    style.BorderRight == eStyleBorderType.Double && style.BorderBottom == eStyleBorderType.Double) ||
                   (style.BorderTop == eStyleBorderType.None && style.BorderLeft == eStyleBorderType.Double &&
                   style.BorderRight == eStyleBorderType.Double && style.BorderBottom == eStyleBorderType.Double))
                    {
                    Rectangle r = bounds;
                    Region oldClip = null;
                    bool clipSet = false;
                    if (style.BorderTop == eStyleBorderType.None)
                    {
                        Rectangle clipRect = r;
                        clipRect.Width++;
                        clipRect.Height++;
                        e.Graphics.SetClip(clipRect);
                        r.Y -= 3;
                        r.Height += 3;
                    }
                    using(GraphicsPath path = DisplayHelp.GetBorderPath(r, style.CornerDiameter, eStyleBackgroundPathPart.Complete,
                        cornerTopLeft, cornerTopRight, cornerBottomLeft, cornerBottomRight, style.PaintLeftBorder, style.PaintRightBorder, 
                        style.PaintTopBorder, style.PaintBottomBorder))
                    {
                        using (Pen pen = new Pen(style.BorderColor, style.BorderWidth))
                            path.Widen(pen);
                        DisplayHelp.FillPath(e.Graphics, path, style.BorderColor, style.BorderColor2);
                    }
                    r.Inflate(-style.BorderWidth, -style.BorderWidth);
                    using (GraphicsPath path = DisplayHelp.GetBorderPath(r, style.CornerDiameter, eStyleBackgroundPathPart.Complete,
                        cornerTopLeft, cornerTopRight, cornerBottomLeft, cornerBottomRight, style.PaintLeftBorder, style.PaintRightBorder,
                        style.PaintTopBorder, style.PaintBottomBorder))
                    {
                        using (Pen pen = new Pen(style.BorderColor, style.BorderWidth))
                            path.Widen(pen);
                        DisplayHelp.FillPath(e.Graphics, path, style.BorderColorLight, style.BorderColorLight2);
                    }

                    if (clipSet)
                        e.Graphics.Clip = oldClip;

                    return;
                }
            }

            Color colorStart = style.BorderColor;
            Color colorEnd = style.BorderColor2;
            Color colorLightStart = style.BorderColorLight;
            Color colorLightEnd = style.BorderColorLight2;

			if(style.PaintLeftBorder)
			{
				Color color=style.BorderColor;
				if(!style.BorderLeftColor.IsEmpty)
					color=style.BorderLeftColor;
				Point[] p=new Point[2];

				// Corner type square is default setting
				p[0]=bounds.Location;
				p[1].X=bounds.X;
				p[1].Y=bounds.Bottom;

				if(cornerTopLeft!=eCornerType.Square)
				{
					p[0].Y+=style.CornerDiameter;
				}
				if(cornerBottomLeft!=eCornerType.Square)
				{
					p[1].Y-=style.CornerDiameter;
				}

                ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.Left);

				if(style.PaintTopBorder && cornerTopLeft!=eCornerType.Square)
				{
					if(cornerTopLeft==eCornerType.Diagonal)
					{
						p[0].X=bounds.X;
						p[0].Y=bounds.Y+style.CornerDiameter;
						p[1].X=bounds.X+style.CornerDiameter;
						p[1].Y=bounds.Y;
                        ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.TopLeft);
					}
					else if(cornerTopLeft==eCornerType.Rounded)
					{
						ArcData a=GetCornerArc(bounds,style.CornerDiameter,eCornerArc.TopLeft);// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
						ElementStyleDisplay.DrawCornerArc(e.Graphics,a,style.BorderLeft,style.BorderLeftWidth,color);
					}
				}

				if(style.PaintBottomBorder && cornerBottomLeft!=eCornerType.Square)
				{
					if(cornerBottomLeft==eCornerType.Diagonal)
					{
						p[0].X=bounds.X;
						p[0].Y=bounds.Bottom-style.CornerDiameter;
						p[1].X=bounds.X+style.CornerDiameter;
						p[1].Y=bounds.Bottom;
                        ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.BottomLeft);
					}
					else if(cornerBottomLeft==eCornerType.Rounded)
					{
						ArcData a=GetCornerArc(bounds,style.CornerDiameter,eCornerArc.BottomLeft);// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
						ElementStyleDisplay.DrawCornerArc(e.Graphics,a,style.BorderLeft,style.BorderLeftWidth,color);
					}
				}
			}

			if(style.PaintTopBorder)
			{
				Color color=style.BorderColor;
				if(!style.BorderTopColor.IsEmpty)
					color=style.BorderTopColor;
				Point[] p=new Point[2];
				// Default setting for Square corner type on both sides
				p[0]=bounds.Location;
				p[1].X=bounds.Right;
				p[1].Y=bounds.Y;

				if(cornerTopLeft!=eCornerType.Square)
				{
					p[0].X+=style.CornerDiameter;
				}
				if(cornerTopRight!=eCornerType.Square)
				{
					p[1].X-=style.CornerDiameter;
				}
                ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderTop, style.BorderTopWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.Top);
			}

			if(style.PaintBottomBorder)
			{
				Color color=style.BorderColor;
				if(!style.BorderBottomColor.IsEmpty)
					color=style.BorderBottomColor;
				Point[] p=new Point[2];
				// Default for Square corner type on both sides
				p[0].X=bounds.X;
				p[0].Y=bounds.Bottom;
				p[1].X=bounds.Right;
				p[1].Y=bounds.Bottom;

				if(cornerBottomLeft!=eCornerType.Square)
				{
					p[0].X+=style.CornerDiameter;
				}
				if(cornerBottomRight!=eCornerType.Square)
				{
					p[1].X-=style.CornerDiameter;
				}

                ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderBottom, style.BorderBottomWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.Bottom);
			}

			if(style.PaintRightBorder)
			{
				Color color=style.BorderColor;
				if(!style.BorderRightColor.IsEmpty)
					color=style.BorderRightColor;
				Point[] p=new Point[2];
				// Default for Square corner type on both sides
				p[0].X=bounds.Right;
				p[0].Y=bounds.Y;
				p[1].X=bounds.Right;
				p[1].Y=bounds.Bottom;

				if(cornerTopRight!=eCornerType.Square)
				{
					p[0].Y+=style.CornerDiameter;
				}
				if(cornerBottomRight!=eCornerType.Square)
				{
					p[1].Y-=style.CornerDiameter;
				}

                ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderRight, style.BorderRightWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.Right);

				if(style.PaintTopBorder && cornerTopRight!=eCornerType.Square)
				{
					if(cornerTopRight==eCornerType.Diagonal)
					{
						p[0].X=bounds.Right-style.CornerDiameter;
						p[0].Y=bounds.Y;
						p[1].X=bounds.Right;
						p[1].Y=bounds.Y+style.CornerDiameter;
                        ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderRightWidth, color, colorEnd, colorLightStart, colorLightEnd, eBorderSide.TopRight);
					}
					else if(cornerTopRight==eCornerType.Rounded)
					{
						ArcData a=GetCornerArc(bounds,style.CornerDiameter,eCornerArc.TopRight);// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
						ElementStyleDisplay.DrawCornerArc(e.Graphics,a,style.BorderLeft,style.BorderLeftWidth,color);
					}
				}

				if(style.PaintBottomBorder && cornerBottomRight!=eCornerType.Square)
				{
					if(cornerBottomRight==eCornerType.Diagonal)
					{
						p[0].X=bounds.Right;
						p[0].Y=bounds.Bottom-style.CornerDiameter;
						p[1].X=bounds.Right-style.CornerDiameter;
						p[1].Y=bounds.Bottom;
						ElementStyleDisplay.DrawBorderLine(e.Graphics,p,style.BorderLeft,style.BorderRightWidth,color, colorEnd, colorLightStart, colorLightEnd,eBorderSide.BottomRight);
					}
					else if(cornerBottomRight==eCornerType.Rounded)
					{
						ArcData a=GetCornerArc(bounds,style.CornerDiameter,eCornerArc.BottomRight);// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
						ElementStyleDisplay.DrawCornerArc(e.Graphics,a,style.BorderLeft,style.BorderLeftWidth,color);
					}
				}
			}

		}

		private static Pen CreatePen(eStyleBorderType border,int lineWidth, Color color)
		{
			Pen pen=new Pen(color,lineWidth);
			pen.Alignment=PenAlignment.Inset;
			pen.DashStyle=ElementStyleDisplay.GetDashStyle(border);
			return pen;
		}

		private static void DrawBorderLine(Graphics g,Point[] p,eStyleBorderType border,int lineWidth, Color colorStart, Color colorEnd, Color colorLightStart, Color colorLightEnd, eBorderSide side)
		{
            if (border == eStyleBorderType.Etched || border == eStyleBorderType.Double)
            {
                if (colorLightStart.IsEmpty)
                {
                    colorLightStart = System.Windows.Forms.ControlPaint.Light(colorStart);
                    colorStart = System.Windows.Forms.ControlPaint.Dark(colorStart);
                }

                if (side == eBorderSide.Bottom || side == eBorderSide.Right)
                {
                    Color ct1 = colorStart;
                    Color ct2 = colorEnd;
                    colorStart = colorLightStart;
                    colorEnd = colorLightEnd;
                    colorLightStart = ct1;
                    colorLightEnd = ct2;
                }

                DisplayHelp.DrawGradientLine(g, p[0], p[1], colorStart, colorEnd, 90, lineWidth);
                
                if (side == eBorderSide.Top)
                {
                    p[0].Y+=lineWidth;
                    p[1].Y += lineWidth;
                }
                else if (side == eBorderSide.Bottom)
                {
                    p[0].Y -= lineWidth;
                    p[1].Y -= lineWidth;
                }
                else if (side == eBorderSide.Left || side == eBorderSide.BottomLeft || side == eBorderSide.TopLeft)
                {
                    p[0].X += lineWidth;
                    p[1].X += lineWidth;
                }
                else if (side == eBorderSide.Right || side == eBorderSide.BottomRight || side == eBorderSide.TopRight)
                {
                    p[0].X -= lineWidth;
                    p[1].X -= lineWidth;
                }

                DisplayHelp.DrawGradientLine(g, p[0], p[1], colorLightStart, colorLightEnd, 90, lineWidth);
            }
            else
            {
                if (colorEnd.IsEmpty)
                {
                    SmoothingMode sm = g.SmoothingMode;
                    g.SmoothingMode = SmoothingMode.None;
                    using (Pen pen = CreatePen(border, lineWidth, colorStart))
                        g.DrawLine(pen, p[0], p[1]);
                    g.SmoothingMode = sm;
                }
                else
                    DisplayHelp.DrawGradientLine(g, p[0], p[1], colorStart, colorEnd, 90, lineWidth);
            }
		}

		private static void DrawCornerArc(Graphics g,ArcData arc,eStyleBorderType border,int lineWidth, Color color)
		{
			using(Pen pen=CreatePen(border,lineWidth,color))
			{
				g.DrawArc(pen,arc.X,arc.Y,arc.Width,arc.Height,arc.StartAngle,arc.SweepAngle);
			}
		}

		private static DashStyle GetDashStyle(eStyleBorderType border)
		{
			DashStyle style=DashStyle.Solid;
			switch(border)
			{
				case eStyleBorderType.Dash:
                    style=DashStyle.Dash;
					break;
				case eStyleBorderType.DashDot:
					style=DashStyle.DashDot;
					break;
				case eStyleBorderType.DashDotDot:
					style=DashStyle.DashDotDot;
					break;
				case eStyleBorderType.Dot:
					style=DashStyle.Dot;
					break;
			}
			return style;
		}

        internal static ElementStyle GetElementStyle(ElementStyle style)
        {
            if (style.Class == "")
                return style;
            IElementStyleClassProvider provider = GetIElementStyleClassProvider();
            if (provider != null)
            {
                ElementStyle baseStyle = provider.GetClass(style.Class);
                if (baseStyle != null)
                {
                    return baseStyle;
                }
            }

            return style;
        }

        private static IElementStyleClassProvider GetIElementStyleClassProvider()
        {
#if DOTNETBAR
            if (Rendering.GlobalManager.Renderer is Rendering.Office2007Renderer)
            {
                return ((Rendering.Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable as IElementStyleClassProvider;
            }
#endif
            return null;
        }

		/// <summary>
		/// Paints style background.
		/// </summary>
		/// <param name="e">Style display information.</param>
		public static void PaintBackground(ElementStyleDisplayInfo e)
		{
            Region oldClip = e.Graphics.Clip;
            if (oldClip != null)
                e.Graphics.SetClip(e.Bounds, CombineMode.Intersect);
            else
                e.Graphics.SetClip(e.Bounds, CombineMode.Replace);

            ElementStyle style = GetElementStyle(e.Style);

            SmoothingMode sm = e.Graphics.SmoothingMode;
            e.Graphics.SmoothingMode = SmoothingMode.Default;

			// Paint Background
			Rectangle bounds=DisplayHelp.GetDrawRectangle(ElementStyleDisplay.GetBackgroundRectangle(style,e.Bounds));
			GraphicsPath path;
            path = ElementStyleDisplay.GetBackgroundPath(style, e.Bounds);

            eBackgroundColorBlendType blendType = style.BackColorBlend.GetBlendType();
            if (blendType!=eBackgroundColorBlendType.Invalid)
            {
                if (blendType == eBackgroundColorBlendType.Relative)
                {
                    try
                    {
                        if (style.BackColorGradientType == eGradientType.Linear)
                        {
                            Rectangle rb = bounds;
                            rb.Inflate(1, 1);
                            using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, style.BackColor, style.BackColor2, style.BackColorGradientAngle))
                            {
                                brush.InterpolationColors = style.BackColorBlend.GetColorBlend();
                                e.Graphics.FillPath(brush, path);
                            }
                        }
                        else if (style.BackColorGradientType == eGradientType.Radial)
                        {
                            int d = (int)Math.Sqrt(bounds.Width * bounds.Width + bounds.Height * bounds.Height) + 4;
                            GraphicsPath fillPath = new GraphicsPath();
                            fillPath.AddEllipse(bounds.X - (d - bounds.Width) / 2, bounds.Y - (d - bounds.Height) / 2, d, d);
                            using (PathGradientBrush brush = new PathGradientBrush(fillPath))
                            {
                                brush.CenterColor = style.BackColor;
                                brush.SurroundColors = new Color[] { style.BackColor2 };
                                brush.InterpolationColors = style.BackColorBlend.GetColorBlend();
                                e.Graphics.FillPath(brush, path);
                            }
                            fillPath.Dispose();
                        }
                    }
                    catch
                    {
                        blendType = eBackgroundColorBlendType.Invalid;
                    }
                }
                else
                {
                    Graphics g = e.Graphics;
                    bounds = e.Bounds;
                    if (oldClip != null)
                    {
                        e.Graphics.SetClip(oldClip, CombineMode.Replace);
                        e.Graphics.SetClip(path, CombineMode.Intersect);
                    }
                    else
                        e.Graphics.SetClip(path, CombineMode.Replace);
                    BackgroundColorBlendCollection bc = style.BackColorBlend;
                    for (int i = 0; i < bc.Count; i+=2)
                    {
                        BackgroundColorBlend b1 = bc[i];
                        BackgroundColorBlend b2 = null;
                        if (i < bc.Count)
                            b2 = bc[i + 1];
                        if (b1 != null && b2 != null)
                        {
                            Rectangle rb = new Rectangle(bounds.X, bounds.Y + (int)b1.Position, bounds.Width,
                                (b2.Position == 1f ? bounds.Height : (int)b2.Position) - (int)b1.Position);
                            using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, b1.Color, b2.Color, style.BackColorGradientAngle))
                                g.FillRectangle(brush, rb);
                        }
                    }
                }
            }
            
            if(blendType==eBackgroundColorBlendType.Invalid)
            {
                if (style.BackColor2.IsEmpty)
                {
                    if (!style.BackColor.IsEmpty)
                    {
                        using (SolidBrush brush = new SolidBrush(style.BackColor))
                            e.Graphics.FillPath(brush, path);
                        //if(e.Style.BackColor.A==255)
                        //{
                        //    // Correct problems with FillPath where path was not filled properly...
                        //    using(Pen pen=new Pen(e.Style.BackColor,1))
                        //        e.Graphics.DrawPath(pen,path);
                        //}
                    }
                }
                else if (!style.BackColor.IsEmpty)
                {
                    if (style.BackColorGradientType == eGradientType.Linear)
                    {
                        Rectangle rb = bounds;
                        rb.X--;
                        rb.Height++;
                        rb.Width += 2;
                        using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, style.BackColor, style.BackColor2, style.BackColorGradientAngle))
                        {
                            e.Graphics.FillPath(brush, path);
                        }
                    }
                    else if (style.BackColorGradientType == eGradientType.Radial)
                    {
                        int d = (int)Math.Sqrt(bounds.Width * bounds.Width + bounds.Height * bounds.Height) + 4;
                        GraphicsPath fillPath = new GraphicsPath();
                        fillPath.AddEllipse(bounds.X - (d - bounds.Width) / 2, bounds.Y - (d - bounds.Height) / 2, d, d);
                        using (PathGradientBrush brush = new PathGradientBrush(fillPath))
                        {
                            brush.CenterColor = style.BackColor;
                            brush.SurroundColors = new Color[] { style.BackColor2 };
                            e.Graphics.FillPath(brush, path);
                        }
                        fillPath.Dispose();
                    }
                }
            }

            e.Graphics.SmoothingMode = sm;

            if (oldClip != null)
                e.Graphics.Clip = oldClip;
            else
                e.Graphics.ResetClip();

			
		}
		
		/// <summary>
		/// Paints style background image.
		/// </summary>
		/// <param name="e">Style display information.</param>
		public static void PaintBackgroundImage(ElementStyleDisplayInfo e)
		{
            ElementStyle style = GetElementStyle(e.Style);
			if(style.BackgroundImage==null)
				return;

            Rectangle bounds = DisplayHelp.GetDrawRectangle(ElementStyleDisplay.GetBackgroundRectangle(style, e.Bounds));
			GraphicsPath path;
			if (e.Graphics.SmoothingMode == SmoothingMode.AntiAlias)
			{
				Rectangle r = e.Bounds;
				r.Width--;
				//r.Height--;
                path = ElementStyleDisplay.GetBackgroundPath(style, r);
			}
			else
                path = ElementStyleDisplay.GetBackgroundPath(style, e.Bounds);
			
			ImageAttributes imageAtt=null;

            if (style.BackgroundImageAlpha != 255)
			{
				ColorMatrix colorMatrix=new ColorMatrix();
                colorMatrix.Matrix33 = 255 - style.BackgroundImageAlpha;
				imageAtt=new ImageAttributes();
				imageAtt.SetColorMatrix(colorMatrix,ColorMatrixFlag.Default,ColorAdjustType.Bitmap);
			}

			Region clip=e.Graphics.Clip;
			e.Graphics.SetClip(path);

            eStyleBackgroundImage imagePosition = style.BackgroundImagePosition;
            bool transform = false;
            Image backgroundImage = style.BackgroundImage;

            if (e.RightToLeft)
            {
                if (imagePosition == eStyleBackgroundImage.TopLeft)
                {
                    imagePosition = eStyleBackgroundImage.TopRight;
                    transform = true;
                }
                else if (imagePosition == eStyleBackgroundImage.TopRight)
                    imagePosition = eStyleBackgroundImage.TopLeft;
                else if (imagePosition == eStyleBackgroundImage.BottomLeft)
                    imagePosition = eStyleBackgroundImage.BottomRight;
                else if (imagePosition == eStyleBackgroundImage.BottomRight)
                    imagePosition = eStyleBackgroundImage.BottomLeft;
            }

            if (transform)
            {
                backgroundImage = backgroundImage.Clone() as Image;
                backgroundImage.RotateFlip(RotateFlipType.RotateNoneFlipX);
            }

            switch (imagePosition)
			{
				case eStyleBackgroundImage.Stretch:
				{
					if(imageAtt!=null)
                        e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
					else
                        e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel);
					break;
				}
				case eStyleBackgroundImage.Center:
				{
                    Rectangle destRect = new Rectangle(bounds.X, bounds.Y, backgroundImage.Width, backgroundImage.Height);
                    if (bounds.Width > backgroundImage.Width)
                        destRect.X += (bounds.Width - backgroundImage.Width) / 2;
                    if (bounds.Height > backgroundImage.Height)
                        destRect.Y += (bounds.Height - backgroundImage.Height) / 2;
					if(imageAtt!=null)
                        e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
					else
                        e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel);
					
					break;
				}
				case eStyleBackgroundImage.TopLeft:
				case eStyleBackgroundImage.TopRight:
				case eStyleBackgroundImage.BottomLeft:
				case eStyleBackgroundImage.BottomRight:
				{
                    Rectangle destRect = new Rectangle(bounds.X, bounds.Y, backgroundImage.Width, backgroundImage.Height);
                    if (imagePosition == eStyleBackgroundImage.TopRight)
                        destRect.X = bounds.Right - backgroundImage.Width;
                    else if (imagePosition == eStyleBackgroundImage.BottomLeft)
                        destRect.Y = bounds.Bottom - backgroundImage.Height;
                    else if (imagePosition == eStyleBackgroundImage.BottomRight)
					{
                        destRect.Y = bounds.Bottom - backgroundImage.Height;
                        destRect.X = bounds.Right - backgroundImage.Width;
					}

					if(imageAtt!=null)
                        e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
					else
                        e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel);
					break;
				}
				case eStyleBackgroundImage.Tile:
				{
					if(imageAtt!=null)
					{
                        if (bounds.Width > backgroundImage.Width || bounds.Height > backgroundImage.Height)
						{
							int x=bounds.X,y=bounds.Y;
							while(y<bounds.Bottom)
							{
								while(x<bounds.Right)
								{
                                    Rectangle destRect = new Rectangle(x, y, backgroundImage.Width, backgroundImage.Height);
									if(destRect.Right>bounds.Right)
										destRect.Width=destRect.Width-(destRect.Right-bounds.Right);
									if(destRect.Bottom>bounds.Bottom)
										destRect.Height=destRect.Height-(destRect.Bottom-bounds.Bottom);
                                    e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, destRect.Width, destRect.Height, GraphicsUnit.Pixel, imageAtt);
                                    x += backgroundImage.Width;
								}
								x=bounds.X;
                                y += backgroundImage.Height;
							}
						}
						else
						{
                            e.Graphics.DrawImage(backgroundImage, new Rectangle(0, 0, backgroundImage.Width, backgroundImage.Height), 0, 0, backgroundImage.Width, backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
						}
					}
					else
					{
                        TextureBrush brush = new TextureBrush(backgroundImage);
						brush.WrapMode=WrapMode.Tile;
						e.Graphics.FillPath(brush,path);
						brush.Dispose();
					}
					break;
				}
			}
            if (transform)
            {
                backgroundImage.Dispose();
            }

			if (clip != null)
				e.Graphics.Clip = clip;
			else
				e.Graphics.ResetClip();
		}

		/// <summary>
		/// Returns background rectangle for given style by taking in account margins.
		/// </summary>
		/// <param name="style">Reference to style object.</param>
		/// <param name="bounds">Style bounds</param>
		/// <returns>Background rectangle.</returns>
		public static Rectangle GetBackgroundRectangle(ElementStyle style, Rectangle bounds)
		{
			// Reduce the bounds rectangle size by the margin size
			bounds.X+=style.MarginLeft;
			bounds.Width-=(style.MarginLeft+style.MarginRight);
			bounds.Y+=style.MarginTop;
			bounds.Height-=(style.MarginTop+style.MarginBottom);
			return bounds;
		}

		private static Rectangle GetBorderRectangle(ElementStyle style, Rectangle bounds)
		{
			bounds=GetBackgroundRectangle(style,bounds);
			if(style.PaintRightBorder)
			{
				if(style.BorderRightWidth<=1)
					bounds.Width-=style.BorderRightWidth;
				else
					bounds.Width-=style.BorderRightWidth/2;
			}

			if(style.PaintBottomBorder)
			{
				if(style.BorderBottomWidth<=1)
					bounds.Height-=style.BorderBottomWidth;
				else
					bounds.Height-=style.BorderBottomWidth/2;
			}

			if(style.PaintLeftBorder && style.BorderLeftWidth>1)
			{
				bounds.X+=style.BorderLeftWidth/2;
				bounds.Width-=style.BorderLeftWidth/2;
			}

			if(style.PaintTopBorder && style.BorderTopWidth>1)
			{
				bounds.X+=style.BorderTopWidth/2;
				bounds.Width-=style.BorderTopWidth/2;
			}

			return bounds;
		}

		private static Rectangle GetTextRectangle(ElementStyle style, Rectangle bounds)
		{
			bounds=ElementStyleDisplay.GetBackgroundRectangle(style,bounds);

			// Reduce the bounds rectangle size by the padding size
			bounds.X+=style.PaddingLeft;
			bounds.Width-=(style.PaddingLeft+style.PaddingRight);
			bounds.Y+=style.PaddingTop;
			bounds.Height-=(style.PaddingTop+style.PaddingBottom);
			return bounds;
		}
		
		/// <summary>
		/// Returns GraphicsPath for given style.
		/// </summary>
		/// <param name="style">Reference to style.</param>
		/// <param name="bounds">Style bounds.</param>
		/// <returns>New instance of GraphicsPath</returns>
		public static GraphicsPath GetBackgroundPath(ElementStyle style, Rectangle bounds)
		{
			return GetBackgroundPath(style, bounds, eStyleBackgroundPathPart.Complete);
		}

		/// <summary>
		/// Returns GraphicsPath for given style.
		/// </summary>
		/// <param name="style">Reference to style.</param>
		/// <param name="bounds">Style bounds.</param>
		/// <returns>New instance of GraphicsPath</returns>
		public static GraphicsPath GetBackgroundPath(ElementStyle style, Rectangle bounds, eStyleBackgroundPathPart pathPart)
		{
			GraphicsPath path=new GraphicsPath();
			
			Rectangle clientRectangle;
			//if(drawPath)
				clientRectangle=/*DisplayHelp.GetDrawRectangle*/(ElementStyleDisplay.GetBackgroundRectangle(style,bounds));
			//else
            //   clientRectangle =/*DisplayHelp.GetDrawRectangle*/(ElementStyleDisplay.GetBackgroundRectangle(style, bounds));

            if (pathPart==eStyleBackgroundPathPart.Complete && style.CornerTypeBottomLeft == eCornerType.Inherit && style.CornerTypeBottomRight == eCornerType.Inherit &&
                style.CornerTypeTopLeft == eCornerType.Inherit && style.CornerTypeTopRight == eCornerType.Inherit)
            {
                switch (style.CornerType)
                {
                    case eCornerType.Square:
                        {
                            path.AddRectangle(clientRectangle);
                            break;
                        }
                    case eCornerType.Rounded:
                        {
                            ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopLeft);
                            path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                            ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopRight);
                            path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                            ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomRight);
                            path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                            ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomLeft);
                            path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                            path.CloseAllFigures();
                            break;
                        }
                    case eCornerType.Diagonal:
                        {
                            path.AddLine(clientRectangle.X, clientRectangle.Bottom - style.CornerDiameter - 1, clientRectangle.X, clientRectangle.Y + style.CornerDiameter);
                            path.AddLine(clientRectangle.X + style.CornerDiameter, clientRectangle.Y, clientRectangle.Right - style.CornerDiameter, clientRectangle.Y);
                            path.AddLine(clientRectangle.Right, clientRectangle.Y + style.CornerDiameter, clientRectangle.Right, clientRectangle.Bottom - style.CornerDiameter - 1);
                            path.AddLine(clientRectangle.Right - style.CornerDiameter - 1, clientRectangle.Bottom, clientRectangle.X + style.CornerDiameter, clientRectangle.Bottom);
                            path.CloseAllFigures();
                            break;
                        }
                }
            }
            else
            {
				if(pathPart==eStyleBackgroundPathPart.TopHalf)
					clientRectangle.Height = clientRectangle.Height/2;
				else if(pathPart==eStyleBackgroundPathPart.BottomHalf)
				{
					int h=clientRectangle.Height;
					clientRectangle.Height = clientRectangle.Height/2;
					clientRectangle.Y += (h - clientRectangle.Height-1);
				}
            	
                eCornerType corner = style.CornerTypeTopLeft;
                if (corner == eCornerType.Inherit)
                    corner = style.CornerType;

            	if(pathPart==eStyleBackgroundPathPart.BottomHalf)
            		corner=eCornerType.Square;
            		
                if (corner == eCornerType.Rounded)
                {
                    ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopLeft);
                    path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                }
                else if (corner == eCornerType.Diagonal)
                {
                    path.AddLine(clientRectangle.X, clientRectangle.Y + style.CornerDiameter, clientRectangle.X + style.CornerDiameter, clientRectangle.Y);
                }
                else
                {
                    path.AddLine(clientRectangle.X, clientRectangle.Y + 2, clientRectangle.X, clientRectangle.Y);
                    path.AddLine(clientRectangle.X, clientRectangle.Y ,clientRectangle.X+2, clientRectangle.Y);
                }

                corner = style.CornerTypeTopRight;
                if (corner == eCornerType.Inherit)
                    corner = style.CornerType;
				if(pathPart==eStyleBackgroundPathPart.BottomHalf)
					corner=eCornerType.Square;
                if (corner == eCornerType.Rounded)
                {
                    ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopRight);
                    path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                }
                else if (corner == eCornerType.Diagonal)
                {
                    path.AddLine(clientRectangle.Right-style.CornerDiameter-1, clientRectangle.Y , clientRectangle.Right, clientRectangle.Y+style.CornerDiameter);
                }
                else
                {
                    path.AddLine(clientRectangle.Right-2, clientRectangle.Y, clientRectangle.Right, clientRectangle.Y);
                    path.AddLine(clientRectangle.Right, clientRectangle.Y, clientRectangle.Right, clientRectangle.Y+2);
                }

                corner = style.CornerTypeBottomRight;
                if (corner == eCornerType.Inherit)
                    corner = style.CornerType;
				if(pathPart==eStyleBackgroundPathPart.TopHalf)
					corner=eCornerType.Square;
                if (corner == eCornerType.Rounded)
                {
                    ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomRight);
                    path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                }
                else if (corner == eCornerType.Diagonal)
                {
                    path.AddLine(clientRectangle.Right, clientRectangle.Bottom - style.CornerDiameter - 1, clientRectangle.Right - style.CornerDiameter - 1, clientRectangle.Bottom);
                }
                else
                {
                    path.AddLine(clientRectangle.Right, clientRectangle.Bottom-2, clientRectangle.Right, clientRectangle.Bottom);
                    path.AddLine(clientRectangle.Right, clientRectangle.Bottom, clientRectangle.Right-2, clientRectangle.Bottom);
                }

                corner = style.CornerTypeBottomLeft;
                if (corner == eCornerType.Inherit)
                    corner = style.CornerType;
				if(pathPart==eStyleBackgroundPathPart.TopHalf)
					corner=eCornerType.Square;
                if (corner == eCornerType.Rounded)
                {
                    ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomLeft);
                    path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
                }
                else if (corner == eCornerType.Diagonal)
                {
                    path.AddLine(clientRectangle.X + 2, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom - style.CornerDiameter - 1);
                }
                else
                {
                    path.AddLine(clientRectangle.X+2, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom);
                    path.AddLine(clientRectangle.X, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom-2);
                }
            }

			return path;
		}

        internal static void AddCornerArc(GraphicsPath path, Rectangle bounds, int cornerDiameter, eCornerArc corner)
        {
            ArcData a = GetCornerArc(bounds, cornerDiameter, corner);
            path.AddArc(a.X, a.Y, a.Width, a.Height, a.StartAngle, a.SweepAngle);
        }

		internal static ArcData GetCornerArc(Rectangle bounds, int cornerDiameter, eCornerArc corner)
		{
			ArcData a;
			int diameter=cornerDiameter*2;
			switch(corner)
			{
				case eCornerArc.TopLeft:
					a=new ArcData(bounds.X,bounds.Y,diameter,diameter,180,90);
					break;
                case eCornerArc.TopRight:
					a=new ArcData(bounds.Right-diameter,bounds.Y,diameter,diameter,270,90);
					break;
				case eCornerArc.BottomLeft:
					a=new ArcData(bounds.X,bounds.Bottom-diameter,diameter,diameter,90,90);
					break;
				default: // eCornerArc.BottomRight:
					a=new ArcData(bounds.Right-diameter,bounds.Bottom-diameter,diameter,diameter,0,90);
					break;
			}
			return a; 
		}

		enum eBorderSide
		{
			Top,
			Bottom,
			Left,
			Right,
			TopLeft,
			TopRight,
			BottomLeft,
			BottomRight
		}
	}

    internal enum eCornerArc
    {
        TopLeft,
        TopRight,
        BottomLeft,
        BottomRight
    }

	/// <summary>
	/// Represents information neccessary to paint the style on canvas.
	/// </summary>
	public class ElementStyleDisplayInfo
	{
		/// <summary>Reference to ElementStyle object.</summary>
		public ElementStyle Style=null;
		/// <summary>Reference to Graphics object.</summary>
		public Graphics Graphics=null;
		/// <summary>ElementStyle bounds.</summary>
		public Rectangle Bounds=Rectangle.Empty;
        /// <summary>Get or sets whether layout is right-to-left.</summary>
        public bool RightToLeft = false;

        /// <summary>Creates new instance of the object.</summary>
		public ElementStyleDisplayInfo()
		{
		}

		/// <summary>Creates new instance of the object and initializes it with default values.</summary>
		/// <param name="style">Style to initialize object with.</param>
		/// <param name="g">Graphics object to initialize object with.</param>
		/// <param name="bounds">Bounds to initialize object with.</param>
		public ElementStyleDisplayInfo(ElementStyle style, Graphics g, Rectangle bounds)
		{
			this.Style=style;
			this.Graphics=g;
			this.Bounds=bounds;
		}
//		public ElementStyleDisplayInfo(ElementStyle style, System.Drawing.Graphics g, Rectangle bounds, string text, Rectangle textBounds)
//		{
//			this.Style=style;
//			this.Graphics=g;
//			this.Bounds=bounds;
//			this.Text=text;
//			this.TextBounds=textBounds;
//		}
	}
	
	#region eStyleBackgroundPathPart
	/// <summary>
	/// Specifies part of the background path.
	/// </summary>
	public enum eStyleBackgroundPathPart
	{
		/// <summary>
		/// Indicates complete background path
		/// </summary>
		Complete,
		/// <summary>
		/// Indicates Top half of background path
		/// </summary>
		TopHalf,
		/// <summary>
		/// Indicates Bottom half of background path
		/// </summary>
		BottomHalf
	}
	#endregion

	#region ArcData
	internal struct ArcData
	{
		public int X;
		public int Y;
		public int Width;
		public int Height;
		public float StartAngle;
		public float SweepAngle;
		public ArcData(int x, int y, int width, int height, float startAngle, float sweepAngle)
		{
			this.X=x;
			this.Y=y;
			this.Width=width;
			this.Height=height;
			this.StartAngle=startAngle;
			this.SweepAngle=sweepAngle;
		}
	}
	#endregion
}