//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:		CalloutAnnotation.cs
//
//  Namespace:	System.Web.UI.WebControls[Windows.Forms].Charting
//
//	Classes:	CalloutAnnotation
//
//  Purpose:	Callout annotation classes.
//
//	Reviewed:	
//
//===================================================================

#region Used namespace
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Text;
using System.Drawing.Drawing2D;
#if Microsoft_CONTROL
using System.Windows.Forms.DataVisualization.Charting;
using System.Windows.Forms.DataVisualization.Charting.Data;
using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
using System.Windows.Forms.DataVisualization.Charting.Utilities;
using System.Windows.Forms.DataVisualization.Charting.Borders3D;

#else
using System.Web;
using System.Web.UI;
using System.Web.UI.DataVisualization.Charting;
using System.Web.UI.DataVisualization.Charting.Data;
using System.Web.UI.DataVisualization.Charting.Utilities;
using System.Web.UI.DataVisualization.Charting.Borders3D;
#endif


#endregion

#if Microsoft_CONTROL
namespace System.Windows.Forms.DataVisualization.Charting

#else
namespace System.Web.UI.DataVisualization.Charting

#endif
{
	#region Enumerations

	/// <summary>
	/// Annotation callout style.
	/// <seealso cref="CalloutAnnotation.CalloutStyle"/>
	/// </summary>
	[
	SRDescription("DescriptionAttributeCalloutStyle_CalloutStyle"),
	]
	public enum CalloutStyle
	{
		/// <summary>
		/// Callout text is underlined and a line is pointing to the anchor point.
		/// </summary>
		SimpleLine,

		/// <summary>
		/// Border is drawn around text and a line is pointing to the anchor point.
		/// </summary>
		Borderline,

		/// <summary>
		/// Callout text is inside the cloud and smaller clouds are pointing to the anchor point.
		/// </summary>
		Cloud,

		/// <summary>
		/// Rectangle is drawn around the callout text, which is connected with the anchor point.
		/// </summary>
		Rectangle,

		/// <summary>
		/// Rounded rectangle is drawn around the callout text, which is connected with the anchor point.
		/// </summary>
		RoundedRectangle,

		/// <summary>
		/// Ellipse is drawn around the callout text, which is connected with the anchor point.
		/// </summary>
		Ellipse,

		/// <summary>
		/// Perspective rectangle is drawn around the callout text, which is connected with the anchor point.
		/// </summary>
		Perspective,
	}

	#endregion

	/// <summary>
	/// <b>CalloutAnnotation</b> is a class class that represents a callout annotation.
	/// </summary>
	/// <remarks>
	/// Callout annotation is the only annotation that draws a connection between the
	/// annotation position and anchor point. It can display text and automatically 
	/// calculate the required size. Different <see cref="CalloutStyle"/> are supported.
	/// </remarks>
	[
		SRDescription("DescriptionAttributeCalloutAnnotation_CalloutAnnotation"),
	]
#if ASPPERM_35
	[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
	public class CalloutAnnotation : TextAnnotation
	{
		#region Fields

		// Callout anchor type 
		private		LineAnchorCapStyle		_calloutAnchorCap = LineAnchorCapStyle.Arrow;

		// Callout drawing style
		private		CalloutStyle		_calloutStyle = CalloutStyle.Rectangle;

		// Cloud shape path
		private		static				GraphicsPath	_cloudPath = null;

		// Cloud shape outline path
		private		static				GraphicsPath	_cloudOutlinePath = null;

		// Cloud shape boundary rectangle
		private		static				RectangleF	_cloudBounds = RectangleF.Empty;

		#endregion

		#region Construction and Initialization

		/// <summary>
		/// Default public constructor.
		/// </summary>
		public CalloutAnnotation() 
            : base()
		{
			// Changing default values of properties
			this.anchorOffsetX = 3.0;
			this.anchorOffsetY = 3.0;
			this.anchorAlignment = ContentAlignment.BottomLeft;
		}

		#endregion

		#region Properties

		#region	Callout properties

        /// <summary>
        /// Gets or sets the annotation callout style.
        /// </summary>
        /// <value>
        /// <see cref="CalloutStyle"/> of the annotation.
        /// </value>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(CalloutStyle.Rectangle),
		SRDescription("DescriptionAttributeCalloutAnnotation_CalloutStyle"),
		ParenthesizePropertyNameAttribute(true),
		]
		virtual public CalloutStyle CalloutStyle
		{
			get
			{
				return _calloutStyle;
			}
			set
			{
				_calloutStyle = value;
				this.ResetCurrentRelativePosition();
				
				// Reset content size to empty
				contentSize = SizeF.Empty;

				Invalidate();
			}
		}

        /// <summary>
        /// Gets or sets the anchor cap style of a callout line.
        /// </summary>
        /// <value>
        /// A <see cref="LineAnchorCapStyle"/> value used as the anchor cap of a callout line.
        /// </value>
        /// <remarks>
        /// This property sets the anchor cap of the line connecting an annotation to 
        /// its anchor point. It only applies when SimpleLine or BorderLine 
        /// are used.
        /// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(LineAnchorCapStyle.Arrow),
		SRDescription("DescriptionAttributeCalloutAnnotation_CalloutAnchorCap"),
		]
		virtual public LineAnchorCapStyle CalloutAnchorCap
		{
			get
			{
				return _calloutAnchorCap;
			}
			set
			{
				_calloutAnchorCap = value;
				Invalidate();
			}
		}
		#endregion // Callout properties

		#region Applicable Annotation Appearance Attributes (set as Browsable)

		/// <summary>
		/// Gets or sets the color of an annotation line.
		/// <seealso cref="LineWidth"/>
		/// <seealso cref="LineDashStyle"/>
		/// </summary>
		/// <value>
		/// A <see cref="Color"/> value used to draw an annotation line.
		/// </value>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(typeof(Color), "Black"),
        SRDescription("DescriptionAttributeLineColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base)
		]
		override public Color LineColor
		{
			get
			{
				return base.LineColor;
			}
			set
			{
				base.LineColor = value;
			}
		}

		/// <summary>
		/// Gets or sets the width of an annotation line.
		/// <seealso cref="LineColor"/>
		/// <seealso cref="LineDashStyle"/>
		/// </summary>
		/// <value>
		/// An integer value defining the width of an annotation line in pixels.
		/// </value>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(1),
        SRDescription("DescriptionAttributeLineWidth"),
		]
		override public int LineWidth
		{
			get
			{
				return base.LineWidth;
			}
			set
			{
				base.LineWidth = value;

			}
		}

		/// <summary>
		/// Gets or sets the style of an annotation line.
		/// <seealso cref="LineWidth"/>
		/// <seealso cref="LineColor"/>
		/// </summary>
		/// <value>
		/// A <see cref="ChartDashStyle"/> value used to draw an annotation line.
		/// </value>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(ChartDashStyle.Solid),
        SRDescription("DescriptionAttributeLineDashStyle"),
		]
		override public ChartDashStyle LineDashStyle
		{
			get
			{
				return base.LineDashStyle;
			}
			set
			{
				base.LineDashStyle = value;
			}
		}

		/// <summary>
		/// Gets or sets the background color of an annotation.
		/// <seealso cref="BackSecondaryColor"/>
		/// <seealso cref="BackHatchStyle"/>
		/// <seealso cref="BackGradientStyle"/>
		/// </summary>
		/// <value>
		/// A <see cref="Color"/> value used for the background of an annotation.
		/// </value>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeBackColor"),
		NotifyParentPropertyAttribute(true),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base)
		]
		override public Color BackColor
		{
			get
			{
				return base.BackColor;
			}
			set
			{
				base.BackColor = value;
			}
		}

		/// <summary>
		/// Gets or sets the background hatch style of an annotation.
		/// <seealso cref="BackSecondaryColor"/>
		/// <seealso cref="BackColor"/>
		/// <seealso cref="BackGradientStyle"/>
		/// </summary>
		/// <value>
		/// A <see cref="ChartHatchStyle"/> value used for the background of an annotation.
		/// </value>
		/// <remarks>
		/// Two colors are used to draw the hatching, <see cref="BackColor"/> and <see cref="BackSecondaryColor"/>.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(ChartHatchStyle.None),
		NotifyParentPropertyAttribute(true),
        SRDescription("DescriptionAttributeBackHatchStyle"),
		Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
		]
		override public ChartHatchStyle BackHatchStyle
		{
			get
			{
				return base.BackHatchStyle;
			}
			set
			{
				base.BackHatchStyle = value;
			}
		}

		/// <summary>
		/// Gets or sets the background gradient style of an annotation.
		/// <seealso cref="BackSecondaryColor"/>
		/// <seealso cref="BackColor"/>
		/// <seealso cref="BackHatchStyle"/>
		/// </summary>
		/// <value>
		/// A <see cref="GradientStyle"/> value used for the background of an annotation.
		/// </value>
		/// <remarks>
		/// Two colors are used to draw the gradient, <see cref="BackColor"/> and <see cref="BackSecondaryColor"/>.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(GradientStyle.None),
		NotifyParentPropertyAttribute(true),
        	SRDescription("DescriptionAttributeBackGradientStyle"),
		Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
		]		
		override public GradientStyle BackGradientStyle
		{
			get
			{
				return base.BackGradientStyle;
			}
			set
			{
				base.BackGradientStyle = value;
			}
		}

		/// <summary>
		/// Gets or sets the secondary background color of an annotation.
		/// <seealso cref="BackColor"/>
		/// <seealso cref="BackHatchStyle"/>
		/// <seealso cref="BackGradientStyle"/>
		/// </summary>
		/// <value>
		/// A <see cref="Color"/> value used for the secondary color of an annotation background with 
		/// hatching or gradient fill.
		/// </value>
		/// <remarks>
		/// This color is used with <see cref="BackColor"/> when <see cref="BackHatchStyle"/> or
		/// <see cref="BackGradientStyle"/> are used.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		Browsable(true),
		DefaultValue(typeof(Color), ""),
		NotifyParentPropertyAttribute(true),
        SRDescription("DescriptionAttributeBackSecondaryColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base)
		] 
		override public Color BackSecondaryColor
		{
			get
			{
				return base.BackSecondaryColor;
			}
			set
			{
				base.BackSecondaryColor = value;
			}
		}

		#endregion

		#region Anchor

        /// <summary>
        /// Gets or sets the x-coordinate offset between the positions of an annotation and its anchor point.
        /// <seealso cref="AnchorOffsetY"/>
        /// <seealso cref="Annotation.AnchorDataPoint"/>
        /// <seealso cref="Annotation.AnchorX"/>
        /// <seealso cref="AnchorAlignment"/>
        /// </summary>
        /// <value>
        /// A double value that represents the x-coordinate offset between the positions of an annotation and its anchor point.
        /// </value>
        /// <remarks>
        /// The annotation must be anchored using the <see cref="Annotation.AnchorDataPoint"/> or 
        /// <see cref="Annotation.AnchorX"/> properties, and its <see cref="Annotation.X"/> property must be set 
        /// to <b>Double.NaN</b>.
        /// </remarks>
		[
		SRCategory("CategoryAttributeAnchor"),
		DefaultValue(3.0),
		SRDescription("DescriptionAttributeCalloutAnnotation_AnchorOffsetX"),
		RefreshPropertiesAttribute(RefreshProperties.All),
		]
		override public double AnchorOffsetX
		{
			get
			{
				return base.AnchorOffsetX;
			}
			set
			{
				base.AnchorOffsetX = value;
			}
		}

		/// <summary>
        /// Gets or sets the y-coordinate offset between the positions of an annotation and its anchor point.
		/// <seealso cref="Annotation.AnchorOffsetX"/>
		/// <seealso cref="Annotation.AnchorDataPoint"/>
		/// <seealso cref="Annotation.AnchorY"/>
		/// <seealso cref="Annotation.AnchorAlignment"/>
		/// </summary>
		/// <value>
        /// A double value that represents the y-coordinate offset between the positions of an annotation and its anchor point.
		/// </value>
		/// <remarks>
		/// Annotation must be anchored using <see cref="Annotation.AnchorDataPoint"/> or 
		/// <see cref="Annotation.AnchorY"/> properties and its <see cref="Annotation.Y"/> property must be set
		/// to <b>Double.NaN</b>.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAnchor"),
		DefaultValue(3.0),
		SRDescription("DescriptionAttributeCalloutAnnotation_AnchorOffsetY"),
		RefreshPropertiesAttribute(RefreshProperties.All),
		]
		override public double AnchorOffsetY
		{
			get
			{
				return base.AnchorOffsetY;
			}
			set
			{
				base.AnchorOffsetY = value;
			}
		}

        /// <summary>
        /// Gets or sets an annotation position's alignment to the anchor point.
        /// <seealso cref="Annotation.AnchorX"/>
        /// <seealso cref="Annotation.AnchorY"/>
        /// <seealso cref="Annotation.AnchorDataPoint"/>
        /// <seealso cref="AnchorOffsetX"/>
        /// <seealso cref="AnchorOffsetY"/>
        /// </summary>
        /// <value>
        /// A <see cref="ContentAlignment"/> value that represents the annotation's alignment to 
        /// the anchor point.
        /// </value>
        /// <remarks>
        /// The annotation must be anchored using either <see cref="Annotation.AnchorDataPoint"/>, or the <see cref="Annotation.AnchorX"/> 
        /// and <see cref="Annotation.AnchorY"/> properties. Its <see cref="Annotation.X"/> and <see cref="Annotation.Y"/> 
        /// properties must be set to <b>Double.NaN</b>.
        /// </remarks>
		[
		SRCategory("CategoryAttributeAnchor"),
		DefaultValue(typeof(ContentAlignment), "BottomLeft"),
		SRDescription("DescriptionAttributeAnchorAlignment"),
		]
		override public ContentAlignment AnchorAlignment
		{
			get
			{
				return base.AnchorAlignment;
			}
			set
			{
				base.AnchorAlignment = value;
			}
		}

		#endregion	// Anchoring

		#region Other

        /// <summary>
        /// Gets or sets an annotation's type name.
        /// </summary>
        /// <remarks>
        /// This property is used to get the name of each annotation type  
        /// (e.g. Line, Rectangle, Ellipse). 
        /// <para>
        /// This property is for internal use and is hidden at design and run time.
        /// </para>
        /// </remarks>	
		[
		SRCategory("CategoryAttributeMisc"),
		Bindable(true),
		Browsable(false),
		EditorBrowsableAttribute(EditorBrowsableState.Never),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden),
		SRDescription("DescriptionAttributeAnnotationType"),
		]
		public override string AnnotationType
		{
			get
			{
				return "Callout";
			}
		}

		/// <summary>
		/// Gets or sets annotation selection points style.
		/// </summary>
		/// <value>
		/// A <see cref="SelectionPointsStyle"/> value that represents annotation
		/// selection style.
		/// </value>
		/// <remarks>
        /// This property is for internal use and is hidden at design and run time.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		DefaultValue(SelectionPointsStyle.Rectangle),
		ParenthesizePropertyNameAttribute(true),
		Browsable(false),
		EditorBrowsableAttribute(EditorBrowsableState.Never),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden),
		SRDescription("DescriptionAttributeSelectionPointsStyle"),
		]
		override internal SelectionPointsStyle SelectionPointsStyle
		{
			get
			{
				return SelectionPointsStyle.Rectangle;
			}
		}

		#endregion

		#endregion

		#region Methods

		#region Text Spacing

		/// <summary>
		/// Gets text spacing on four different sides in relative coordinates.
		/// </summary>
		/// <param name="annotationRelative">Indicates that spacing is in annotation relative coordinates.</param>
		/// <returns>Rectangle with text spacing values.</returns>
		internal override RectangleF GetTextSpacing(out bool annotationRelative)
		{
			RectangleF spacing = base.GetTextSpacing(out annotationRelative);
			if(this._calloutStyle == CalloutStyle.Cloud ||
				this._calloutStyle == CalloutStyle.Ellipse)
			{
				spacing = new RectangleF(4f, 4f, 4f, 4f);
				annotationRelative = true;
			}
			else if(this._calloutStyle == CalloutStyle.RoundedRectangle)
			{
				spacing = new RectangleF(1f, 1f, 1f, 1f);
				annotationRelative = true;
			}

			return spacing;
		}

		#endregion // Text Spacing

		#region Painting

		/// <summary>
		/// Paints annotation object on specified graphics.
		/// </summary>
		/// <param name="graphics">
		/// A <see cref="ChartGraphics"/> used to paint annotation object.
		/// </param>
		/// <param name="chart">
		/// Reference to the <see cref="Chart"/> control.
		/// </param>
		override internal void Paint(Chart chart, ChartGraphics graphics)
		{
			// Get annotation position in relative coordinates
			PointF firstPoint = PointF.Empty;
			PointF anchorPoint = PointF.Empty;
			SizeF size = SizeF.Empty;
			GetRelativePosition(out firstPoint, out size, out anchorPoint);
			PointF	secondPoint = new PointF(firstPoint.X + size.Width, firstPoint.Y + size.Height);

			// Create selection rectangle
			RectangleF selectionRect = new RectangleF(firstPoint, new SizeF(secondPoint.X - firstPoint.X, secondPoint.Y - firstPoint.Y));

			// Adjust negative rectangle width and height
			RectangleF	rectanglePosition = new RectangleF(selectionRect.Location, selectionRect.Size);
			if(rectanglePosition.Width < 0)
			{
				rectanglePosition.X = rectanglePosition.Right;
				rectanglePosition.Width = -rectanglePosition.Width;
			}
			if(rectanglePosition.Height < 0)
			{
				rectanglePosition.Y = rectanglePosition.Bottom;
				rectanglePosition.Height = -rectanglePosition.Height;
			}

			// Check if position is valid
			if( float.IsNaN(rectanglePosition.X) || 
				float.IsNaN(rectanglePosition.Y) || 
				float.IsNaN(rectanglePosition.Right) || 
				float.IsNaN(rectanglePosition.Bottom) )
			{
				return;
			}

			// Paint different style of callouts
			GraphicsPath hotRegionPathAbs = null;
			if(this.Common.ProcessModePaint)
			{
				switch(this._calloutStyle)
				{
					case(CalloutStyle.SimpleLine):
						hotRegionPathAbs = DrawRectangleLineCallout(
							graphics,
							rectanglePosition,
							anchorPoint,
							false);
						break;
					case(CalloutStyle.Borderline):
						hotRegionPathAbs = DrawRectangleLineCallout(
							graphics,
							rectanglePosition,
							anchorPoint,
							true);
						break;
					case(CalloutStyle.Perspective):
						hotRegionPathAbs = DrawPerspectiveCallout(
							graphics,
							rectanglePosition,
							anchorPoint);
						break;
					case(CalloutStyle.Cloud):
						hotRegionPathAbs = DrawCloudCallout(
							graphics,
							rectanglePosition,
							anchorPoint);
						break;
					case(CalloutStyle.Rectangle):
						hotRegionPathAbs = DrawRectangleCallout(
							graphics,
							rectanglePosition,
							anchorPoint);
						break;
					case(CalloutStyle.Ellipse):
						hotRegionPathAbs = DrawRoundedRectCallout(
							graphics,
							rectanglePosition,
							anchorPoint,
							true);
						break;
					case(CalloutStyle.RoundedRectangle):
						hotRegionPathAbs = DrawRoundedRectCallout(
							graphics,
							rectanglePosition,
							anchorPoint,
							false);
						break;
				}
			}

			if(this.Common.ProcessModeRegions)
			{
				if(hotRegionPathAbs != null)
				{
					// If there is more then one graphical path split them and create 
					// image maps for every graphical path separately.
					GraphicsPathIterator iterator = new GraphicsPathIterator(hotRegionPathAbs);

					// There is more then one path.
                    using (GraphicsPath subPath = new GraphicsPath())
                    {
                        while (iterator.NextMarker(subPath) > 0)
                        {
                            // Use callout defined hot region
                            this.Common.HotRegionsList.AddHotRegion(
                                graphics,
                                subPath,
                                false,
                                ReplaceKeywords(this.ToolTip),
#if Microsoft_CONTROL
							String.Empty,
							String.Empty,
							String.Empty,
#else // Microsoft_CONTROL
 ReplaceKeywords(this.Url),
				            ReplaceKeywords(this.MapAreaAttributes),
                            ReplaceKeywords(this.PostBackValue),
#endif // Microsoft_CONTROL
 this,
                                ChartElementType.Annotation);

                            // Reset current path
                            subPath.Reset();
                        }
                    }
				}
				else
				{
					// Use rectangular hot region
					this.Common.HotRegionsList.AddHotRegion(
						rectanglePosition,
						ReplaceKeywords(this.ToolTip),
#if Microsoft_CONTROL
						String.Empty,
						String.Empty,
						String.Empty,
#else // Microsoft_CONTROL
                        ReplaceKeywords(this.Url),
					    ReplaceKeywords(this.MapAreaAttributes),
                        ReplaceKeywords(this.PostBackValue),
#endif // Microsoft_CONTROL
						this,
						ChartElementType.Annotation,
						String.Empty);
				}
			}

            //Clean up
            if (hotRegionPathAbs != null)
                hotRegionPathAbs.Dispose();

			// Paint selection handles
			PaintSelectionHandles(graphics, selectionRect, null);
		}

		/// <summary>
		/// Draws Rounded rectangle or Ellipse style callout.
		/// </summary>
		/// <param name="graphics">Chart graphics.</param>
		/// <param name="rectanglePosition">Position of annotation objet.</param>
		/// <param name="anchorPoint">Anchor location.</param>
		/// <param name="isEllipse">True if ellipse shape should be used.</param>
		/// <returns>Hot region of the callout.</returns>
		private GraphicsPath DrawRoundedRectCallout(
			ChartGraphics graphics,
			RectangleF rectanglePosition,
			PointF anchorPoint,
			bool isEllipse)
		{
			// Get absolute position
			RectangleF rectanglePositionAbs = graphics.GetAbsoluteRectangle(rectanglePosition);

            // NOTE: Fix for issue #6692.
            // Do not draw the callout if size is not set. This may happen if callou text is set to empty string.
            if (rectanglePositionAbs.Width <= 0 || rectanglePositionAbs.Height <= 0)
            {
                return null;
            }

			// Create ellipse path
			GraphicsPath ellipsePath = new GraphicsPath();
			if(isEllipse)
			{
				// Add ellipse shape
				ellipsePath.AddEllipse(rectanglePositionAbs);
			}
			else
			{
				// Add rounded rectangle shape
				float radius = Math.Min(rectanglePositionAbs.Width, rectanglePositionAbs.Height);
				radius /= 5f;
				ellipsePath = this.CreateRoundedRectPath(rectanglePositionAbs, radius);
			}

			// Draw perspective polygons from anchoring point
			if(!float.IsNaN(anchorPoint.X) && !float.IsNaN(anchorPoint.Y))
			{
				// Check if point is inside annotation position
				if(!rectanglePosition.Contains(anchorPoint.X, anchorPoint.Y))
				{
					// Get absolute anchor point
					PointF anchorPointAbs = graphics.GetAbsolutePoint(new PointF(anchorPoint.X, anchorPoint.Y));

					// Flatten ellipse path
					ellipsePath.Flatten();

					// Find point in the path closest to the anchor point
					PointF[] points = ellipsePath.PathPoints;
					int closestPointIndex = 0;
					int index = 0;
					float currentDistance = float.MaxValue;
					foreach(PointF point in points)
					{
						float deltaX = point.X - anchorPointAbs.X;
						float deltaY = point.Y - anchorPointAbs.Y;
						float distance = deltaX * deltaX + deltaY * deltaY;
						if(distance < currentDistance)
						{
							currentDistance = distance;
							closestPointIndex = index;
						}
						++ index;
					}

					// Change point to the anchor location
					points[closestPointIndex] = anchorPointAbs;

					// Recreate ellipse path
					ellipsePath.Reset();
					ellipsePath.AddLines(points);
					ellipsePath.CloseAllFigures();
				}
			}

			// Draw ellipse
			graphics.DrawPathAbs(
				ellipsePath,
				this.BackColor,
				this.BackHatchStyle,
				String.Empty,
				ChartImageWrapMode.Scaled,
				Color.Empty,
				ChartImageAlignmentStyle.Center,
				this.BackGradientStyle,
				this.BackSecondaryColor,
				this.LineColor,
				this.LineWidth,
				this.LineDashStyle,
				PenAlignment.Center,
				this.ShadowOffset,
				this.ShadowColor);

			// Draw text 
			DrawText(graphics, rectanglePosition, true, false);

			return ellipsePath;
		}

		/// <summary>
		/// Draws Rectangle style callout.
		/// </summary>
		/// <param name="graphics">Chart graphics.</param>
		/// <param name="rectanglePosition">Position of annotation objet.</param>
		/// <param name="anchorPoint">Anchor location.</param>
		/// <returns>Hot region of the callout.</returns>
		private GraphicsPath DrawRectangleCallout(
			ChartGraphics graphics,
			RectangleF rectanglePosition,
			PointF anchorPoint)
		{
			// Create path for the rectangle connected with anchor point.
			GraphicsPath	hotRegion = null;
			bool anchorVisible = false;
			if(!float.IsNaN(anchorPoint.X) && !float.IsNaN(anchorPoint.Y))
			{
				// Get relative size of a pixel
				SizeF pixelSize = graphics.GetRelativeSize(new SizeF(1f, 1f));

				// Increase annotation position rectangle by 1 pixel
				RectangleF inflatedPosition = new RectangleF(rectanglePosition.Location, rectanglePosition.Size);
				inflatedPosition.Inflate(pixelSize);

				// Check if point is inside annotation position
				if(!inflatedPosition.Contains(anchorPoint.X, anchorPoint.Y))
				{
					anchorVisible = true;

					// Get absolute position
					RectangleF rectanglePositionAbs = graphics.GetAbsoluteRectangle(rectanglePosition);

					// Get absolute anchor point
					PointF anchorPointAbs = graphics.GetAbsolutePoint(new PointF(anchorPoint.X, anchorPoint.Y));

					// Calculate anchor pointer thicness
					float size = Math.Min(rectanglePositionAbs.Width, rectanglePositionAbs.Height);
					size /= 4f;

					// Create shape points
					PointF[] points = new PointF[7];
					if(anchorPoint.X < rectanglePosition.X && 
						anchorPoint.Y > rectanglePosition.Bottom)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[3] = new PointF(rectanglePositionAbs.X + size, rectanglePositionAbs.Bottom);
						points[4] = anchorPointAbs;
						points[5] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom - size);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom - size);
					}
					else if(anchorPoint.X >= rectanglePosition.X && 
						anchorPoint.X <= rectanglePosition.Right &&
						anchorPoint.Y > rectanglePosition.Bottom)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[3] = new PointF(rectanglePositionAbs.X + rectanglePositionAbs.Width / 2f + size, rectanglePositionAbs.Bottom);
						points[4] = anchorPointAbs;
						points[5] = new PointF(rectanglePositionAbs.X + rectanglePositionAbs.Width / 2f - size, rectanglePositionAbs.Bottom);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
					}
					else if(anchorPoint.X > rectanglePosition.Right && 
						anchorPoint.Y > rectanglePosition.Bottom)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom - size);
						points[3] = anchorPointAbs;
						points[4] = new PointF(rectanglePositionAbs.Right - size, rectanglePositionAbs.Bottom);
						points[5] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
					}
					else if(anchorPoint.X > rectanglePosition.Right && 
						anchorPoint.Y <= rectanglePosition.Bottom && 
						anchorPoint.Y >= rectanglePosition.Y)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y + rectanglePositionAbs.Height / 2f - size);
						points[3] = anchorPointAbs;
						points[4] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y + rectanglePositionAbs.Height / 2f + size);
						points[5] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
					}
					else if(anchorPoint.X > rectanglePosition.Right && 
						anchorPoint.Y < rectanglePosition.Y)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right - size, rectanglePositionAbs.Y);
						points[2] = anchorPointAbs;
						points[3] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y + size);
						points[4] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[5] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
					}
					else if(anchorPoint.X >= rectanglePosition.X && 
						anchorPoint.X <= rectanglePosition.Right && 
						anchorPoint.Y < rectanglePosition.Y)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.X + rectanglePositionAbs.Width/2f - size, rectanglePositionAbs.Y);
						points[2] = anchorPointAbs;
						points[3] = new PointF(rectanglePositionAbs.X + rectanglePositionAbs.Width/2f + size, rectanglePositionAbs.Y);
						points[4] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[5] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
					}
					else if(anchorPoint.X < rectanglePosition.X &&
						anchorPoint.Y < rectanglePosition.Y)
					{
						points[0] = anchorPointAbs;
						points[1] = new PointF(rectanglePositionAbs.X + size, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[3] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[4] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
						points[5] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y + size);
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y + size);
					}
					else if(anchorPoint.X < rectanglePosition.X &&
						anchorPoint.Y >= rectanglePosition.Y &&
						anchorPoint.Y <= rectanglePosition.Bottom)
					{
						points[0] = rectanglePositionAbs.Location;
						points[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
						points[2] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
						points[3] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
						points[4] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y + rectanglePositionAbs.Height/2f + size );
						points[5] = anchorPointAbs;
						points[6] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y + rectanglePositionAbs.Height/2f - size );
					}

					// Create graphics path of the callout
                    hotRegion = new GraphicsPath();
                
                    hotRegion.AddLines(points);
                    hotRegion.CloseAllFigures();

                    // Draw callout
                    graphics.DrawPathAbs(
                        hotRegion,
                        this.BackColor,
                        this.BackHatchStyle,
                        String.Empty,
                        ChartImageWrapMode.Scaled,
                        Color.Empty,
                        ChartImageAlignmentStyle.Center,
                        this.BackGradientStyle,
                        this.BackSecondaryColor,
                        this.LineColor,
                        this.LineWidth,
                        this.LineDashStyle,
                        PenAlignment.Center,
                        this.ShadowOffset,
                        this.ShadowColor);
                
				}
			}
		
			// Draw rectangle if anchor is not visible
			if(!anchorVisible)
			{
				graphics.FillRectangleRel(
					rectanglePosition,
					this.BackColor,
					this.BackHatchStyle,
					String.Empty,
					ChartImageWrapMode.Scaled,
					Color.Empty,
					ChartImageAlignmentStyle.Center,
					this.BackGradientStyle,
					this.BackSecondaryColor,
					this.LineColor,
					this.LineWidth,
					this.LineDashStyle,
					this.ShadowColor,
					this.ShadowOffset,
					PenAlignment.Center);

				// Get hot region
				hotRegion = new GraphicsPath();
				hotRegion.AddRectangle( graphics.GetAbsoluteRectangle(rectanglePosition) );
			}

			// Draw text 
			DrawText(graphics, rectanglePosition, false, false);

			return hotRegion;
		}

		/// <summary>
		/// Draws Perspective style callout.
		/// </summary>
		/// <param name="graphics">Chart graphics.</param>
		/// <param name="rectanglePosition">Position of annotation objet.</param>
		/// <param name="anchorPoint">Anchor location.</param>
		/// <returns>Hot region of the cloud.</returns>
		private GraphicsPath DrawCloudCallout(
			ChartGraphics graphics,
			RectangleF rectanglePosition,
			PointF anchorPoint)
		{
			// Get absolute position
			RectangleF rectanglePositionAbs = graphics.GetAbsoluteRectangle(rectanglePosition);

			// Draw perspective polygons from anchoring point
			if(!float.IsNaN(anchorPoint.X) && !float.IsNaN(anchorPoint.Y))
			{
				// Check if point is inside annotation position
				if(!rectanglePosition.Contains(anchorPoint.X, anchorPoint.Y))
				{
					// Get center point of the cloud
					PointF cloudCenterAbs = graphics.GetAbsolutePoint(
						new PointF(
						rectanglePosition.X + rectanglePosition.Width / 2f, 
						rectanglePosition.Y + rectanglePosition.Height / 2f) );

					// Calculate absolute ellipse size and position
					SizeF ellipseSize = graphics.GetAbsoluteSize(
						new SizeF(rectanglePosition.Width, rectanglePosition.Height));
					ellipseSize.Width /= 10f;
					ellipseSize.Height /= 10f;
					PointF anchorPointAbs = graphics.GetAbsolutePoint(
						new PointF(anchorPoint.X, anchorPoint.Y));
					PointF ellipseLocation = anchorPointAbs;

					// Get distance between anchor point and center of the cloud
					float dxAbs = anchorPointAbs.X - cloudCenterAbs.X;
					float dyAbs = anchorPointAbs.Y - cloudCenterAbs.Y;

					PointF point = PointF.Empty;
					if(anchorPoint.Y < rectanglePosition.Y)
					{
						point = GetIntersectionY(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.Y);
						if(point.X < rectanglePositionAbs.X)
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.X);
						}
						else if(point.X > rectanglePositionAbs.Right)
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.Right);
						}
					}
					else if(anchorPoint.Y > rectanglePosition.Bottom)
					{
						point = GetIntersectionY(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.Bottom);
						if(point.X < rectanglePositionAbs.X)
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.X);
						}
						else if(point.X > rectanglePositionAbs.Right)
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.Right);
						}
					}
					else
					{
						if(anchorPoint.X < rectanglePosition.X)
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.X);
						}
						else
						{
							point = GetIntersectionX(cloudCenterAbs, anchorPointAbs, rectanglePositionAbs.Right);
						}
					}
						
					SizeF size = new SizeF(Math.Abs(cloudCenterAbs.X - point.X), Math.Abs(cloudCenterAbs.Y - point.Y));
					if(dxAbs > 0)
						dxAbs -= size.Width;
					else
						dxAbs += size.Width;

					if(dyAbs > 0)
						dyAbs -= size.Height;
					else
						dyAbs += size.Height;


					// Draw 3 smaller ellipses from anchor point to the cloud
					for(int index = 0; index < 3; index++)
					{
						using( GraphicsPath path = new GraphicsPath() )
						{
							// Create ellipse path
							path.AddEllipse(
								ellipseLocation.X - ellipseSize.Width / 2f,
								ellipseLocation.Y - ellipseSize.Height / 2f,
								ellipseSize.Width,
								ellipseSize.Height);

							// Draw ellipse
							graphics.DrawPathAbs(
								path,
								this.BackColor,
								this.BackHatchStyle,
								String.Empty,
								ChartImageWrapMode.Scaled,
								Color.Empty,
								ChartImageAlignmentStyle.Center,
								this.BackGradientStyle,
								this.BackSecondaryColor,
								this.LineColor,
								1, // this.LineWidth,	NOTE: Cloud supports only 1 pixel border
								this.LineDashStyle,
								PenAlignment.Center,
								this.ShadowOffset,
								this.ShadowColor);

							// Adjust ellipse size
							ellipseSize.Width *= 1.5f;
							ellipseSize.Height *= 1.5f;

							// Adjust next ellipse position
							ellipseLocation.X -= dxAbs / 3f + (index * (dxAbs / 10f) );
							ellipseLocation.Y -= dyAbs / 3f + (index * (dyAbs / 10f) );
						}
					}
				}
			}

			// Draw cloud
			GraphicsPath pathCloud = GetCloudPath(rectanglePositionAbs);
			graphics.DrawPathAbs(
				pathCloud,
				this.BackColor,
				this.BackHatchStyle,
				String.Empty,
				ChartImageWrapMode.Scaled,
				Color.Empty,
				ChartImageAlignmentStyle.Center,
				this.BackGradientStyle,
				this.BackSecondaryColor,
				this.LineColor,
				1, // this.LineWidth,	NOTE: Cloud supports only 1 pixel border
				this.LineDashStyle,
				PenAlignment.Center,
				this.ShadowOffset,
				this.ShadowColor);

			// Draw cloud outline (Do not draw in SVG or Flash Animation)
			{
				using(GraphicsPath pathCloudOutline = GetCloudOutlinePath(rectanglePositionAbs))
				{
					graphics.DrawPathAbs(
						pathCloudOutline,
						this.BackColor,
						this.BackHatchStyle,
						String.Empty,
						ChartImageWrapMode.Scaled,
						Color.Empty,
						ChartImageAlignmentStyle.Center,
						this.BackGradientStyle,
						this.BackSecondaryColor,
						this.LineColor,
						1, // this.LineWidth,	NOTE: Cloud supports only 1 pixel border
						this.LineDashStyle,
						PenAlignment.Center);
				}
			}
			
			// Draw text 
			DrawText(graphics, rectanglePosition, true, false);

			return pathCloud;
		}

		/// <summary>
		/// Draws Perspective style callout.
		/// </summary>
		/// <param name="graphics">Chart graphics.</param>
		/// <param name="rectanglePosition">Position of annotation objet.</param>
		/// <param name="anchorPoint">Anchor location.</param>
		/// <returns>Hot region of the cloud.</returns>
		private GraphicsPath DrawPerspectiveCallout(
			ChartGraphics graphics,
			RectangleF rectanglePosition,
			PointF anchorPoint)
		{
			// Draw rectangle
			graphics.FillRectangleRel(
				rectanglePosition,
				this.BackColor,
				this.BackHatchStyle,
				String.Empty,
				ChartImageWrapMode.Scaled,
				Color.Empty,
				ChartImageAlignmentStyle.Center,
				this.BackGradientStyle,
				this.BackSecondaryColor,
				this.LineColor,
				this.LineWidth,
				this.LineDashStyle,
				this.ShadowColor,
				0,	// Shadow is never drawn
				PenAlignment.Center);

			// Create hot region path
			GraphicsPath hotRegion = new GraphicsPath();
			hotRegion.AddRectangle( graphics.GetAbsoluteRectangle(rectanglePosition) );

			// Draw text 
			DrawText(graphics, rectanglePosition, false, false);

			// Draw perspective polygons from anchoring point
			if(!float.IsNaN(anchorPoint.X) && !float.IsNaN(anchorPoint.Y))
			{
				// Check if point is inside annotation position
				if(!rectanglePosition.Contains(anchorPoint.X, anchorPoint.Y))
				{
					Color[] perspectivePathColors = new Color[2];
					Color color = (this.BackColor.IsEmpty) ? Color.White : this.BackColor;
					perspectivePathColors[0] = graphics.GetBrightGradientColor(color, 0.6);
					perspectivePathColors[1] = graphics.GetBrightGradientColor(color, 0.8);
					GraphicsPath[] perspectivePaths = new GraphicsPath[2];
					using(perspectivePaths[0] = new GraphicsPath()) 
					{
						using(perspectivePaths[1] = new GraphicsPath()) 
						{
							// Convert coordinates to absolute
							RectangleF rectanglePositionAbs = graphics.GetAbsoluteRectangle(rectanglePosition);
							PointF anchorPointAbs = graphics.GetAbsolutePoint(anchorPoint);

							// Create paths of perspective
							if(anchorPoint.Y < rectanglePosition.Y)
							{
								PointF[] points1 = new PointF[3];
								points1[0] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y);
								points1[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
								points1[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
								perspectivePaths[0].AddLines(points1);
								if(anchorPoint.X < rectanglePosition.X)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
								else if(anchorPoint.X > rectanglePosition.Right)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
							}
							else if(anchorPoint.Y > rectanglePosition.Bottom)
							{
								PointF[] points1 = new PointF[3];
								points1[0] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
								points1[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
								points1[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
								perspectivePaths[0].AddLines(points1);
								if(anchorPoint.X < rectanglePosition.X)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
								else if(anchorPoint.X > rectanglePosition.Right)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
							}
							else
							{
								if(anchorPoint.X < rectanglePosition.X)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.X, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
								else if(anchorPoint.X > rectanglePosition.Right)
								{
									PointF[] points2 = new PointF[3];
									points2[0] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Bottom);
									points2[1] = new PointF(rectanglePositionAbs.Right, rectanglePositionAbs.Y);
									points2[2] = new PointF(anchorPointAbs.X, anchorPointAbs.Y);
									perspectivePaths[1].AddLines(points2);
								}
							}

							// Draw paths if non-empty
							int index = 0;
							foreach(GraphicsPath path in perspectivePaths)
							{
								if(path.PointCount > 0)
								{
									path.CloseAllFigures();
									graphics.DrawPathAbs(
										path,
										perspectivePathColors[index],
										this.BackHatchStyle,
										String.Empty,
										ChartImageWrapMode.Scaled,
										Color.Empty,
										ChartImageAlignmentStyle.Center,
										this.BackGradientStyle,
										this.BackSecondaryColor,
										this.LineColor,
										this.LineWidth,
										this.LineDashStyle,
										PenAlignment.Center);

									// Add area to hot region path
									hotRegion.SetMarkers();
									hotRegion.AddPath( path, false );
								}
								++index;
							}
						}
					}
				}
			}

			return hotRegion;
		}

		/// <summary>
		/// Draws SimpleLine or BorderLine style callout.
		/// </summary>
		/// <param name="graphics">Chart graphics.</param>
		/// <param name="rectanglePosition">Position of annotation objet.</param>
		/// <param name="anchorPoint">Anchor location.</param>
		/// <param name="drawRectangle">If true draws BorderLine style, otherwise SimpleLine.</param>
		/// <returns>Hot region of the cloud.</returns>
		private GraphicsPath DrawRectangleLineCallout(
			ChartGraphics graphics,
			RectangleF rectanglePosition,
			PointF anchorPoint,
			bool drawRectangle)
		{
			// Rectangle mode
			if(drawRectangle)
			{
				// Draw rectangle
				graphics.FillRectangleRel(
					rectanglePosition,
					this.BackColor,
					this.BackHatchStyle,
					String.Empty,
					ChartImageWrapMode.Scaled,
					Color.Empty,
					ChartImageAlignmentStyle.Center,
					this.BackGradientStyle,
					this.BackSecondaryColor,
					this.LineColor,
					this.LineWidth,
					this.LineDashStyle,
					this.ShadowColor,
					this.ShadowOffset,
					PenAlignment.Center);

				// Draw text 
				DrawText(graphics, rectanglePosition, false, false);
			}
			else
			{
				// Draw text 
				rectanglePosition = DrawText(graphics, rectanglePosition, false, true);
				SizeF pixelSize = graphics.GetRelativeSize(new SizeF(2f, 2f));
				rectanglePosition.Inflate(pixelSize);
			}

			// Create hot region path
			GraphicsPath hotRegion = new GraphicsPath();
			hotRegion.AddRectangle( graphics.GetAbsoluteRectangle(rectanglePosition) );

			// Define position of text underlying line
			PointF	textLinePoint1 = new PointF(rectanglePosition.X, rectanglePosition.Bottom);
			PointF	textLinePoint2 = new PointF(rectanglePosition.Right, rectanglePosition.Bottom);

			// Draw line to the anchor point
			if(!float.IsNaN(anchorPoint.X) && !float.IsNaN(anchorPoint.Y))
			{
				// Check if point is inside annotation position
				if(!rectanglePosition.Contains(anchorPoint.X, anchorPoint.Y))
				{
					PointF	lineSecondPoint = PointF.Empty;
					if(anchorPoint.X < rectanglePosition.X)
					{
						lineSecondPoint.X = rectanglePosition.X;
					}
					else if(anchorPoint.X > rectanglePosition.Right)
					{
						lineSecondPoint.X = rectanglePosition.Right;
					}
					else
					{
						lineSecondPoint.X = rectanglePosition.X + rectanglePosition.Width / 2f;
					}

					if(anchorPoint.Y < rectanglePosition.Y)
					{
						lineSecondPoint.Y = rectanglePosition.Y;
					}
					else if(anchorPoint.Y > rectanglePosition.Bottom)
					{
						lineSecondPoint.Y = rectanglePosition.Bottom;
					}
					else
					{
						lineSecondPoint.Y = rectanglePosition.Y + rectanglePosition.Height / 2f;
					}

					// Set line caps
					bool capChanged = false;
					LineCap	oldStartCap = LineCap.Flat;
					if(this.CalloutAnchorCap != LineAnchorCapStyle.None)
					{
						// Save old pen
						capChanged = true;
						oldStartCap = graphics.Pen.StartCap;

						// Apply anchor cap settings
						if(this.CalloutAnchorCap == LineAnchorCapStyle.Arrow)
						{
							// Adjust arrow size for small line width
							if(this.LineWidth < 4)
							{
								int adjustment = 3 - this.LineWidth;
                                graphics.Pen.StartCap = LineCap.Custom;
                                graphics.Pen.CustomStartCap = new AdjustableArrowCap(
									this.LineWidth + adjustment, 
									this.LineWidth + adjustment, 
									true);
							}
							else
							{
                                graphics.Pen.StartCap = LineCap.ArrowAnchor;
							}
						}
						else if(this.CalloutAnchorCap == LineAnchorCapStyle.Diamond)
						{
                            graphics.Pen.StartCap = LineCap.DiamondAnchor;
						}
						else if(this.CalloutAnchorCap == LineAnchorCapStyle.Round)
						{
                            graphics.Pen.StartCap = LineCap.RoundAnchor;
						}
						else if(this.CalloutAnchorCap == LineAnchorCapStyle.Square)
						{
                            graphics.Pen.StartCap = LineCap.SquareAnchor;
						}
					}

					// Draw callout line
					graphics.DrawLineAbs(
						this.LineColor,
						this.LineWidth,
						this.LineDashStyle,
						graphics.GetAbsolutePoint(anchorPoint),
						graphics.GetAbsolutePoint(lineSecondPoint),
						this.ShadowColor,
						this.ShadowOffset);

					// Create hot region path
					using( GraphicsPath linePath = new GraphicsPath() )
					{
						linePath.AddLine(						
							graphics.GetAbsolutePoint(anchorPoint),
							graphics.GetAbsolutePoint(lineSecondPoint) );

						linePath.Widen(new Pen(Color.Black, this.LineWidth + 2));
						hotRegion.SetMarkers();
						hotRegion.AddPath( linePath, false );
					}

					// Restore line caps
					if(capChanged)
					{
                        graphics.Pen.StartCap = oldStartCap;
					}

					// Adjust text underlying line position
					if(anchorPoint.Y < rectanglePosition.Y)
					{
						textLinePoint1.Y = rectanglePosition.Y;
						textLinePoint2.Y = rectanglePosition.Y;
					}
					else if(anchorPoint.Y > rectanglePosition.Y && 
						anchorPoint.Y < rectanglePosition.Bottom)
					{
						textLinePoint1.Y = rectanglePosition.Y;
						textLinePoint2.Y = rectanglePosition.Bottom;
						if(anchorPoint.X < rectanglePosition.X)
						{
							textLinePoint1.X = rectanglePosition.X;
							textLinePoint2.X = rectanglePosition.X;
						}
						else
						{
							textLinePoint1.X = rectanglePosition.Right;
							textLinePoint2.X = rectanglePosition.Right;
						}
					}
				}

				// Draw text underlying line
				if(!drawRectangle)
				{
					graphics.DrawLineAbs(
						this.LineColor,
						this.LineWidth,
						this.LineDashStyle,
						graphics.GetAbsolutePoint(textLinePoint1),
						graphics.GetAbsolutePoint(textLinePoint2),
						this.ShadowColor,
						this.ShadowOffset);

					// Create hot region path
					using( GraphicsPath linePath = new GraphicsPath() )
					{
						linePath.AddLine(						
							graphics.GetAbsolutePoint(textLinePoint1),
							graphics.GetAbsolutePoint(textLinePoint2) );

						linePath.Widen(new Pen(Color.Black, this.LineWidth + 2));
						hotRegion.SetMarkers();
						hotRegion.AddPath( linePath, false );
					}

				}
			}

			return hotRegion;
		}

		#endregion // Painting

		#region Anchor Methods

		/// <summary>
		/// Checks if annotation draw anything in the anchor position (except selection handle)
		/// </summary>
		/// <returns>True if annotation "connects" itself and anchor point visually.</returns>
		override internal bool IsAnchorDrawn()
		{
			return true;
		}

		#endregion // Anchor Methods

		#region Helper methods

		/// <summary>
		/// Gets cloud callout outline graphics path.
		/// </summary>
		/// <param name="position">Absolute position of the callout cloud.</param>
		/// <returns>Cloud outline path.</returns>
		private static GraphicsPath GetCloudOutlinePath(RectangleF position)
		{
			if(_cloudOutlinePath == null)
			{
				GetCloudPath(position);
			}

			// Translate and sacle original path to fit specified position
			GraphicsPath resultPath = (GraphicsPath)_cloudOutlinePath.Clone();
			Matrix matrix = new Matrix();
			matrix.Translate(-_cloudBounds.X, -_cloudBounds.Y);
			resultPath.Transform(matrix);
			matrix = new Matrix();
			matrix.Translate(position.X, position.Y);
			matrix.Scale(position.Width / _cloudBounds.Width, position.Height / _cloudBounds.Height);
			resultPath.Transform(matrix);

			return resultPath;
		}
	
		/// <summary>
		/// Gets cloud callout graphics path.
		/// </summary>
		/// <param name="position">Absolute position of the callout cloud.</param>
		/// <returns>Cloud path.</returns>
		private static GraphicsPath GetCloudPath(RectangleF position)
		{
			// Check if cloud path was already created
			if(_cloudPath == null)
			{
				// Create cloud path
				_cloudPath = new GraphicsPath();

				_cloudPath.AddBezier(1689.5f, 1998.6f, 1581.8f, 2009.4f, 1500f, 2098.1f, 1500f, 2204f);

				_cloudPath.AddBezier(1500f, 2204f, 1499.9f, 2277.2f, 1539.8f, 2345.1f, 1604.4f, 2382.1f);

				_cloudPath.AddBezier(1603.3f, 2379.7f, 1566.6f, 2417.8f, 1546.2f, 2468.1f, 1546.2f, 2520.1f);
				_cloudPath.AddBezier(1546.2f, 2520.1f, 1546.2f, 2633.7f, 1641.1f, 2725.7f, 1758.1f, 2725.7f);
				_cloudPath.AddBezier(1758.1f, 2725.7f, 1766.3f, 2725.6f, 1774.6f, 2725.2f, 1782.8f, 2724.2f);

				_cloudPath.AddBezier(1781.7f, 2725.6f, 1848.5f, 2839.4f, 1972.8f, 2909.7f, 2107.3f, 2909.7f);
				_cloudPath.AddBezier(2107.3f, 2909.7f, 2175.4f, 2909.7f, 2242.3f, 2891.6f, 2300.6f, 2857.4f);

				_cloudPath.AddBezier(2300f, 2857.6f, 2360.9f, 2946.5f, 2463.3f, 2999.7f, 2572.9f, 2999.7f);
				_cloudPath.AddBezier(2572.9f, 2999.7f, 2717.5f, 2999.7f, 2845.2f, 2907.4f, 2887.1f, 2772.5f);

				_cloudPath.AddBezier(2887.4f, 2774.3f, 2932.1f, 2801.4f, 2983.6f, 2815.7f, 3036.3f, 2815.7f);
				_cloudPath.AddBezier(3036.3f, 2815.7f, 3190.7f, 2815.7f, 3316.3f, 2694.8f, 3317.5f, 2544.8f);

				_cloudPath.AddBezier(3317f, 2544.1f, 3479.2f, 2521.5f, 3599.7f, 2386.5f, 3599.7f, 2227.2f);
				_cloudPath.AddBezier(3599.7f, 2227.2f, 3599.7f, 2156.7f, 3575.7f, 2088.1f, 3531.6f, 2032.2f);

				_cloudPath.AddBezier(3530.9f, 2032f, 3544.7f, 2000.6f, 3551.9f, 1966.7f, 3551.9f, 1932.5f);
				_cloudPath.AddBezier(3551.9f, 1932.5f, 3551.9f, 1818.6f, 3473.5f, 1718.8f, 3360.7f, 1688.8f);

				_cloudPath.AddBezier(3361.6f, 1688.3f, 3341.4f, 1579.3f, 3243.5f, 1500f, 3129.3f, 1500f);
				_cloudPath.AddBezier(3129.3f, 1500f, 3059.8f, 1499.9f, 2994f, 1529.6f, 2949.1f, 1580.9f);

				_cloudPath.AddBezier(2949.5f, 1581.3f, 2909.4f, 1530f, 2847f, 1500f, 2780.8f, 1500f);
				_cloudPath.AddBezier(2780.8f, 1500f, 2700.4f, 1499.9f, 2626.8f, 1544.2f, 2590.9f, 1614.2f);

				_cloudPath.AddBezier(2591.7f, 1617.6f, 2543.2f, 1571.1f, 2477.9f, 1545.1f, 2409.8f, 1545.1f);
				_cloudPath.AddBezier(2409.8f, 1545.1f, 2313.9f, 1545.1f, 2225.9f, 1596.6f, 2180.8f, 1679f);

				_cloudPath.AddBezier(2180.1f, 1680.7f, 2129.7f, 1652f, 2072.4f, 1636.9f, 2014.1f, 1636.9f);
				_cloudPath.AddBezier(2014.1f, 1636.9f, 1832.8f, 1636.9f, 1685.9f, 1779.8f, 1685.9f, 1956f);
				_cloudPath.AddBezier(1685.9f, 1956f, 1685.8f, 1970.4f, 1686.9f, 1984.8f, 1688.8f, 1999f);

				_cloudPath.CloseAllFigures();


				// Create cloud outline path
				_cloudOutlinePath = new GraphicsPath();

				_cloudOutlinePath.AddBezier(1604.4f, 2382.1f, 1636.8f, 2400.6f, 1673.6f, 2410.3f, 1711.2f, 2410.3f);
				_cloudOutlinePath.AddBezier(1711.2f, 2410.3f, 1716.6f, 2410.3f, 1722.2f, 2410.2f, 1727.6f, 2409.8f);
			
				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(1782.8f, 2724.2f, 1801.3f, 2722.2f, 1819.4f, 2717.7f, 1836.7f, 2711f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(2267.6f, 2797.2f, 2276.1f, 2818.4f, 2287f, 2838.7f, 2300f, 2857.6f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(2887.1f, 2772.5f, 2893.8f, 2750.9f, 2898.1f, 2728.7f, 2900f, 2706.3f);

				// NOTE: This cloud segment overlaps text too much. Removed for now!
				//cloudOutlinePath.StartFigure();
				//cloudOutlinePath.AddBezier(3317.5f, 2544.8f, 3317.5f, 2544f, 3317.6f, 2543.3f, 3317.6f, 2542.6f);
				//cloudOutlinePath.AddBezier(3317.6f, 2542.6f, 3317.6f, 2438.1f, 3256.1f, 2342.8f, 3159.5f, 2297f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(3460.5f, 2124.9f, 3491f, 2099.7f, 3515f, 2067.8f, 3530.9f, 2032f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(3365.3f, 1732.2f, 3365.3f, 1731.1f, 3365.4f, 1730.1f, 3365.4f, 1729f);
				_cloudOutlinePath.AddBezier(3365.4f, 1729f, 3365.4f, 1715.3f, 3364.1f, 1701.7f, 3361.6f, 1688.3f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(2949.1f, 1580.9f, 2934.4f, 1597.8f, 2922.3f, 1616.6f, 2913.1f, 1636.9f);
				_cloudOutlinePath.CloseFigure();

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(2590.9f, 1614.2f, 2583.1f, 1629.6f, 2577.2f, 1645.8f, 2573.4f, 1662.5f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(2243.3f, 1727.5f, 2224.2f, 1709.4f, 2203f, 1693.8f, 2180.1f, 1680.7f);

				_cloudOutlinePath.StartFigure();
				_cloudOutlinePath.AddBezier(1688.8f, 1999f, 1691.1f, 2015.7f, 1694.8f, 2032.2f, 1699.9f, 2048.3f);

				_cloudOutlinePath.CloseAllFigures();

				// Get cloud path bounds
				_cloudBounds = _cloudPath.GetBounds();
			}

			// Translate and sacle original path to fit specified position
			GraphicsPath resultPath = (GraphicsPath)_cloudPath.Clone();
			Matrix matrix = new Matrix();
			matrix.Translate(-_cloudBounds.X, -_cloudBounds.Y);
			resultPath.Transform(matrix);
			matrix = new Matrix();
			matrix.Translate(position.X, position.Y);
			matrix.Scale(position.Width / _cloudBounds.Width, position.Height / _cloudBounds.Height);
			resultPath.Transform(matrix);

			return resultPath;
		}

		/// <summary>
		/// Gets intersection point coordinates between point line and and horizontal 
		/// line specified by Y coordinate.
		/// </summary>
		/// <param name="firstPoint">First data point.</param>
		/// <param name="secondPoint">Second data point.</param>
		/// <param name="pointY">Y coordinate.</param>
		/// <returns>Intersection point coordinates.</returns>
		internal static PointF GetIntersectionY(PointF firstPoint, PointF secondPoint, float pointY)
		{
			PointF	intersectionPoint = new PointF();
			intersectionPoint.Y = pointY;
			intersectionPoint.X = (pointY - firstPoint.Y) *
				(secondPoint.X - firstPoint.X) / 
				(secondPoint.Y - firstPoint.Y) + 
				firstPoint.X;
			return intersectionPoint;
		}

		/// <summary>
		/// Gets intersection point coordinates between point line and and vertical 
		/// line specified by X coordinate.
		/// </summary>
		/// <param name="firstPoint">First data point.</param>
		/// <param name="secondPoint">Second data point.</param>
		/// <param name="pointX">X coordinate.</param>
		/// <returns>Intersection point coordinates.</returns>
		internal static PointF GetIntersectionX(PointF firstPoint, PointF secondPoint, float pointX)
		{
			PointF	intersectionPoint = new PointF();
			intersectionPoint.X = pointX;
			intersectionPoint.Y = (pointX - firstPoint.X) *
				(secondPoint.Y - firstPoint.Y) / 
				(secondPoint.X - firstPoint.X) + 
				firstPoint.Y;
			return intersectionPoint;
		}

		/// <summary>
		/// Adds a horizontal or vertical line into the path as multiple segments.
		/// </summary>
		/// <param name="path">Graphics path.</param>
		/// <param name="x1">First point X coordinate.</param>
		/// <param name="y1">First point Y coordinate.</param>
		/// <param name="x2">Second point X coordinate.</param>
		/// <param name="y2">Second point Y coordinate.</param>
		/// <param name="segments">Number of segments to add.</param>
		private void PathAddLineAsSegments(GraphicsPath path, float x1, float y1, float x2, float y2, int segments)
		{
			if(x1 == x2)
			{
				float distance = (y2 - y1) / segments;
				for(int index = 0; index < segments; index++)
				{
					path.AddLine(x1, y1, x1, y1 + distance);
					y1 += distance;
				}
			}
			else if(y1 == y2)
			{
				float distance = (x2 - x1) / segments;
				for(int index = 0; index < segments; index++)
				{
					path.AddLine(x1, y1, x1 + distance, y1);
					x1 += distance;
				}
			}
			else
			{
                throw (new InvalidOperationException(SR.ExceptionAnnotationPathAddLineAsSegmentsInvalid));
			}
		}
		/// <summary>
		/// Helper function which creates a rounded rectangle path.
		/// Extra points are added on the sides to allow anchor connection.
		/// </summary>
		/// <param name="rect">Rectangle coordinates.</param>
		/// <param name="cornerRadius">Corner radius.</param>
		/// <returns>Graphics path object.</returns>
		private GraphicsPath CreateRoundedRectPath(RectangleF rect, float cornerRadius)
		{
			// Create rounded rectangle path
			GraphicsPath path = new GraphicsPath();
			int segments = 10;
			PathAddLineAsSegments(path, rect.X+cornerRadius, rect.Y, rect.Right-cornerRadius, rect.Y, segments);

			path.AddArc(rect.Right-2f*cornerRadius, rect.Y, 2f*cornerRadius, 2f*cornerRadius, 270, 90);

			PathAddLineAsSegments(path, rect.Right, rect.Y + cornerRadius, rect.Right, rect.Bottom - cornerRadius, segments);

			path.AddArc(rect.Right-2f*cornerRadius, rect.Bottom-2f*cornerRadius, 2f*cornerRadius, 2f*cornerRadius, 0, 90);

			PathAddLineAsSegments(path, rect.Right-cornerRadius, rect.Bottom, rect.X + cornerRadius, rect.Bottom, segments);

			path.AddArc(rect.X, rect.Bottom-2f*cornerRadius, 2f*cornerRadius, 2f*cornerRadius, 90, 90);

			PathAddLineAsSegments(path, rect.X, rect.Bottom-cornerRadius, rect.X, rect.Y+cornerRadius, segments);

			path.AddArc(rect.X, rect.Y, 2f*cornerRadius, 2f*cornerRadius, 180, 90);

			return path;
		}

		#endregion // Helper methods

		#endregion
	}
}