//-------------------------------------------------------------
// <copyright company=Microsoft Corporation>
//   Copyright  Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:		WebCustomControl1.cs
//
//  Namespace:	System.Web.UI.DataVisualization.Charting
//
//	Classes:	Chart, TraceManager 
//				CustomizeMapAreasEventArgs
//
//  Purpose:	Chart web control main class.
//
//	Reviewed:	
//
//===================================================================

#region Used namespaces 

using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing.Design;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Data;
using System.Web;
using System.Net;
using System.IO;
using System.Text;
using System.Reflection;
using System.Diagnostics.CodeAnalysis;

using System.Collections;
using System.Diagnostics;
using System.Xml;
using System.Web.UI.DataVisualization.Charting;
using System.Globalization;

using System.Web.UI.DataVisualization.Charting.Data;
using System.Web.UI.DataVisualization.Charting.Utilities;
using System.Web.UI.DataVisualization.Charting.ChartTypes;
using System.Web.UI.DataVisualization.Charting.Borders3D;

using System.Web.UI.DataVisualization.Charting.Formulas;
using System.Security;
using System.Security.Permissions;



#endregion

namespace System.Web.UI.DataVisualization.Charting
{

	#region Chart enumerations

    /// <summary>
    /// Chart image storage mode.
    /// </summary>
    public enum ImageStorageMode
    {

        /// <summary>
        /// Images are stored using HTTP Handler.
        /// </summary>
        UseHttpHandler,

        /// <summary>
        /// Images is saved in temp. file using ImageLocation specified.
        /// </summary>
        UseImageLocation
    }

	/// <summary>
	/// Specifies the format of the image
	/// </summary>
	public enum ChartImageFormat
	{
		/// <summary>
		/// Gets the Joint Photographic Experts Group (JPEG) image format.
		/// </summary>
		Jpeg,

		/// <summary>
		/// Gets the W3C Portable Network Graphics (PNG) image format.
		/// </summary>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Png")]
        Png,

		/// <summary>
		/// Gets the bitmap image format (BMP).
		/// </summary>
		Bmp,

		/// <summary>
		/// Gets the Tag Image File Format (TIFF) image format.
		/// </summary>
		Tiff,

		/// <summary>
		/// Gets the Graphics Interchange Format (GIF) image format.
		/// </summary>
		Gif,

        /// <summary>
		/// Gets the Enhanced Meta File (Emf) image format.
		/// </summary>
		Emf,

		/// <summary>
		/// Gets the Enhanced Meta File (Emf+) image format.
		/// </summary>
		EmfPlus,

		/// <summary>
		/// Gets the Enhanced Meta File (EmfDual) image format.
		/// </summary>
		EmfDual,
	}

	/// <summary>
	/// Chart image rendering type
	/// </summary>
 	public enum RenderType
	{
        /// <summary>
		/// Chart image is rendered as image tag.
		/// </summary>
		ImageTag, 

		/// <summary>
		/// Chart image is streamed back directly.
		/// </summary>
		BinaryStreaming,

		/// <summary>
		/// Chart image map is rendered.
		/// </summary>
		ImageMap
	}

	#endregion

	/// <summary>
	/// Summary description for enterprize chart control.
	/// </summary>
	[
	ToolboxData("<{0}:Chart runat=server>" +
        "<Series><{0}:Series Name=\"Series1\"></{0}:Series></Series>" +
        "<ChartAreas><{0}:ChartArea Name=\"ChartArea1\"></{0}:ChartArea></ChartAreas>" +
		"</{0}:Chart>"),
	ToolboxBitmap(typeof(Chart), "ChartControl.ico"),
    Designer(Editors.ChartWebDesigner)
	]
    [SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
	[DisplayNameAttribute("Chart")]
    [SupportsEventValidation]
    [DefaultEvent("Load")] 
#if ASPPERM_35
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class Chart : System.Web.UI.WebControls.DataBoundControl, IPostBackEventHandler
	{

        #region Control fields

        /// <summary>
        /// True if smart labels debug markings should be drawn.
        /// This field is for SmartLabels related issues debugging only.
        /// </summary>
        internal bool ShowDebugMarkings = false;

        // Chart services components
		private ChartTypeRegistry				_chartTypeRegistry = null;
		private BorderTypeRegistry				_borderTypeRegistry = null;
        private CustomPropertyRegistry          _customPropertyRegistry = null;
		private DataManager						_dataManager = null;
		internal ChartImage						chartPicture = null;
		private ImageLoader						_imageLoader = null;
		internal static ITypeDescriptorContext	controlCurrentContext = null;
		internal string							webFormDocumentURL = "";
		internal ServiceContainer				serviceContainer = null;

		// Named images collection
		private NamedImagesCollection			_namedImages = null;


		private FormulaRegistry					_formulaRegistry = null;


		// Product ID

		internal static string					productID = "MSC-WCE-10";

		// Control license
		private	License							_license = null;

		// Private data members, which store properties values
		private	RenderType						_renderType = RenderType.ImageTag;
		private string							_chartImageLocation = "ChartPic_#SEQ(300,3)";
        
		// Indicates that chart is serializing the data
		internal bool							serializing = false;

        // Detailed serialization status which allows not only to determine if serialization
        // is curently in process but also check if we are saving, loading or resetting the chart.
        internal SerializationStatus            serializationStatus = SerializationStatus.None;

		// Chart serializer
		private ChartSerializer					_chartSerializer = null;

		// Chart content saved in the view state
		private	SerializationContents 			_viewStateContent = SerializationContents .Default;

		// Image URL the chart will be renderd to
		private string							_currentChartImageLocation = String.Empty;

        // Image Handler URL the chart will be renderd to
        private string                          _currentChartHandlerImageLocation = String.Empty;

		// Indicates if unique GUID should be added to image file name to solve cashing issues
		private bool							_addGuidParam = true;

		private KeywordsRegistry				_keywordsRegistry = null;

    	// Indicates image storage mode.
    	private ImageStorageMode _imageStorageMode = ImageStorageMode.UseHttpHandler;


        // Selection class
        internal Selection                      selection = null;

		#endregion

		#region Constructors and initialization

		/// <summary>
		/// Chart control constructor.
		/// </summary>
		public Chart() : base()
		{
			base.EnableViewState = false;

			//*********************************************************
			//** Create services
			//*********************************************************
			serviceContainer = new ServiceContainer();
			_chartTypeRegistry = new ChartTypeRegistry();
			_borderTypeRegistry = new BorderTypeRegistry();
			_customPropertyRegistry = new CustomPropertyRegistry();

			_keywordsRegistry = new KeywordsRegistry();

			_dataManager = new DataManager(serviceContainer);
			_imageLoader = new ImageLoader(serviceContainer);
			chartPicture = new ChartImage(serviceContainer);
			_chartSerializer = new ChartSerializer(serviceContainer);


			_formulaRegistry = new FormulaRegistry();

			// Add services to the service container
			serviceContainer.AddService(typeof(Chart), this);							// Chart Control
			serviceContainer.AddService(_chartTypeRegistry.GetType(), _chartTypeRegistry);// Chart types registry
			serviceContainer.AddService(_borderTypeRegistry.GetType(), _borderTypeRegistry);// Border types registry
			serviceContainer.AddService(_customPropertyRegistry.GetType(), _customPropertyRegistry);// Custom attribute registry
			serviceContainer.AddService(_dataManager.GetType(), _dataManager);			// Data Manager service
			serviceContainer.AddService(_imageLoader.GetType(), _imageLoader);			// Image Loader service
			serviceContainer.AddService(chartPicture.GetType(), chartPicture);			// Chart image service
			serviceContainer.AddService(_chartSerializer.GetType(), _chartSerializer);	// Chart serializer service


			serviceContainer.AddService(_formulaRegistry.GetType(), _formulaRegistry);			// Formula modules service



			serviceContainer.AddService(_keywordsRegistry.GetType(), _keywordsRegistry);	// Keywords registry



			// Initialize objects
			_dataManager.Initialize();

			// Register known chart types
			_chartTypeRegistry.Register(ChartTypeNames.Bar, typeof(BarChart));
			_chartTypeRegistry.Register(ChartTypeNames.Column, typeof(ColumnChart));
			_chartTypeRegistry.Register(ChartTypeNames.Point, typeof(PointChart));
			_chartTypeRegistry.Register(ChartTypeNames.Bubble, typeof(BubbleChart));
			_chartTypeRegistry.Register(ChartTypeNames.Line, typeof(LineChart));
			_chartTypeRegistry.Register(ChartTypeNames.Spline, typeof(SplineChart));
			_chartTypeRegistry.Register(ChartTypeNames.StepLine, typeof(StepLineChart));
			_chartTypeRegistry.Register(ChartTypeNames.Area, typeof(AreaChart));
			_chartTypeRegistry.Register(ChartTypeNames.SplineArea, typeof(SplineAreaChart));
			_chartTypeRegistry.Register(ChartTypeNames.StackedArea, typeof(StackedAreaChart));
			_chartTypeRegistry.Register(ChartTypeNames.Pie, typeof(PieChart));
			_chartTypeRegistry.Register(ChartTypeNames.Stock, typeof(StockChart));
			_chartTypeRegistry.Register(ChartTypeNames.Candlestick, typeof(CandleStickChart));
			_chartTypeRegistry.Register(ChartTypeNames.Doughnut, typeof(DoughnutChart));
			_chartTypeRegistry.Register(ChartTypeNames.StackedBar, typeof(StackedBarChart));
			_chartTypeRegistry.Register(ChartTypeNames.StackedColumn, typeof(StackedColumnChart));
			_chartTypeRegistry.Register(ChartTypeNames.OneHundredPercentStackedColumn, typeof(HundredPercentStackedColumnChart));
			_chartTypeRegistry.Register(ChartTypeNames.OneHundredPercentStackedBar, typeof(HundredPercentStackedBarChart));
			_chartTypeRegistry.Register(ChartTypeNames.OneHundredPercentStackedArea, typeof(HundredPercentStackedAreaChart));



			_chartTypeRegistry.Register(ChartTypeNames.Range, typeof(RangeChart));
			_chartTypeRegistry.Register(ChartTypeNames.SplineRange, typeof(SplineRangeChart));
			_chartTypeRegistry.Register(ChartTypeNames.RangeBar, typeof(RangeBarChart));
			_chartTypeRegistry.Register(ChartTypeNames.RangeColumn, typeof(RangeColumnChart));
			_chartTypeRegistry.Register(ChartTypeNames.ErrorBar, typeof(ErrorBarChart));
			_chartTypeRegistry.Register(ChartTypeNames.BoxPlot, typeof(BoxPlotChart));
			_chartTypeRegistry.Register(ChartTypeNames.Radar, typeof(RadarChart));



			_chartTypeRegistry.Register(ChartTypeNames.Renko, typeof(RenkoChart));
			_chartTypeRegistry.Register(ChartTypeNames.ThreeLineBreak, typeof(ThreeLineBreakChart));
			_chartTypeRegistry.Register(ChartTypeNames.Kagi, typeof(KagiChart));
			_chartTypeRegistry.Register(ChartTypeNames.PointAndFigure, typeof(PointAndFigureChart));





			_chartTypeRegistry.Register(ChartTypeNames.Polar, typeof(PolarChart));
			_chartTypeRegistry.Register(ChartTypeNames.FastLine, typeof(FastLineChart));
			_chartTypeRegistry.Register(ChartTypeNames.Funnel, typeof(FunnelChart));
			_chartTypeRegistry.Register(ChartTypeNames.Pyramid, typeof(PyramidChart));





			_chartTypeRegistry.Register(ChartTypeNames.FastPoint, typeof(FastPointChart));
            



			// Register known formula modules
            _formulaRegistry.Register(SR.FormulaNamePriceIndicators, typeof(PriceIndicators));
            _formulaRegistry.Register(SR.FormulaNameGeneralTechnicalIndicators, typeof(GeneralTechnicalIndicators));
            _formulaRegistry.Register(SR.FormulaNameTechnicalVolumeIndicators, typeof(VolumeIndicators));
            _formulaRegistry.Register(SR.FormulaNameOscillator, typeof(Oscillators));
            _formulaRegistry.Register(SR.FormulaNameGeneralFormulas, typeof(GeneralFormulas));
            _formulaRegistry.Register(SR.FormulaNameTimeSeriesAndForecasting, typeof(TimeSeriesAndForecasting));
            _formulaRegistry.Register(SR.FormulaNameStatisticalAnalysis, typeof(StatisticalAnalysis));

			// Register known 3D border types
			_borderTypeRegistry.Register("Emboss", typeof(EmbossBorder));
			_borderTypeRegistry.Register("Raised", typeof(RaisedBorder));
			_borderTypeRegistry.Register("Sunken", typeof(SunkenBorder));
			_borderTypeRegistry.Register("FrameThin1", typeof(FrameThin1Border));
			_borderTypeRegistry.Register("FrameThin2", typeof(FrameThin2Border));
			_borderTypeRegistry.Register("FrameThin3", typeof(FrameThin3Border));
			_borderTypeRegistry.Register("FrameThin4", typeof(FrameThin4Border));
			_borderTypeRegistry.Register("FrameThin5", typeof(FrameThin5Border));
			_borderTypeRegistry.Register("FrameThin6", typeof(FrameThin6Border));
			_borderTypeRegistry.Register("FrameTitle1", typeof(FrameTitle1Border));
			_borderTypeRegistry.Register("FrameTitle2", typeof(FrameTitle2Border));
			_borderTypeRegistry.Register("FrameTitle3", typeof(FrameTitle3Border));
			_borderTypeRegistry.Register("FrameTitle4", typeof(FrameTitle4Border));
			_borderTypeRegistry.Register("FrameTitle5", typeof(FrameTitle5Border));
			_borderTypeRegistry.Register("FrameTitle6", typeof(FrameTitle6Border));
			_borderTypeRegistry.Register("FrameTitle7", typeof(FrameTitle7Border));
			_borderTypeRegistry.Register("FrameTitle8", typeof(FrameTitle8Border));

            // Create selection object
            this.selection = new Selection(serviceContainer);

			// Create named images collection
            _namedImages = new NamedImagesCollection();

            // Hook up event handlers
            ChartAreas.NameReferenceChanged += new EventHandler<NameReferenceChangedEventArgs>(Series.ChartAreaNameReferenceChanged);
            ChartAreas.NameReferenceChanged += new EventHandler<NameReferenceChangedEventArgs>(Legends.ChartAreaNameReferenceChanged);
            ChartAreas.NameReferenceChanged += new EventHandler<NameReferenceChangedEventArgs>(Titles.ChartAreaNameReferenceChanged);
            ChartAreas.NameReferenceChanged += new EventHandler<NameReferenceChangedEventArgs>(Annotations.ChartAreaNameReferenceChanged);
            Legends.NameReferenceChanged += new EventHandler<NameReferenceChangedEventArgs>(Series.LegendNameReferenceChanged);

            this.AlternateText = String.Empty;
            this.DescriptionUrl = String.Empty;
        }

		#endregion

		#region Chart rendering methods

        /// <summary>
		/// Gets current image URL the chart control will be rendered into.
		/// </summary>
		/// <returns>Current chart image URL.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings")] 
        [
		    Bindable(false),
		    Browsable(false),
		    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
		    SerializationVisibility(SerializationVisibility.Hidden),
        ]
		public string CurrentImageLocation
		{
            get
            {

                if (this.RenderType == RenderType.ImageTag && this.GetImageStorageMode() == ImageStorageMode.UseHttpHandler)
                {
                    return _currentChartHandlerImageLocation;
                }

                // Image name is already created
                if (this._currentChartImageLocation.Length > 0)
                {
                    return this._currentChartImageLocation;
                }

                // Get picture name
                this._currentChartImageLocation = this.ImageLocation;
                int indexUID = -1;
                if (this.RenderType == RenderType.ImageTag)
                {
                    // Make sure image URL is not empty
                    if (this.ImageLocation.Length == 0)
                    {
                        throw (new InvalidOperationException(SR.ExceptionImageUrlIsEmpty));
                    }
                    // Add file extension if there is no one
                    char[] slashesArray = { '\\', '/' };
                    int pointIndex = _currentChartImageLocation.LastIndexOf('.');
                    int slashIndex = _currentChartImageLocation.LastIndexOfAny(slashesArray);
                    if (pointIndex < 0 || pointIndex < slashIndex)
                    {
                            switch (chartPicture.ImageType)
                            {
                                case (ChartImageType.Bmp):
                                    _currentChartImageLocation += ".bmp";
                                    break;
                                case (ChartImageType.Jpeg):
                                    _currentChartImageLocation += ".jpeg";
                                    break;
                                case (ChartImageType.Png):
                                    _currentChartImageLocation += ".png";
                                    break;
                                case (ChartImageType.Emf):
                                    _currentChartImageLocation += ".emf";
                                    break;
                            }
                    }

                    // Double chech that #UID is not used with #SEQ
                    // Add GUID to the filename 
                    indexUID = _currentChartImageLocation.IndexOf("#UID", StringComparison.Ordinal);
                    int indexSEQ = _currentChartImageLocation.IndexOf("#SEQ", StringComparison.Ordinal);
                    if (indexUID >= 0 && indexSEQ >= 0)
                    {
                        throw (new InvalidOperationException(SR.ExceptionImageUrlInvalidFormatters));
                    }

                    // Add GUID to the filename 
                    if (indexUID >= 0)
                    {
                        // Replace "#UID" with GUID string
                        _currentChartImageLocation = _currentChartImageLocation.Replace("#UID", Guid.NewGuid().ToString());
                    }

                        // Add GUID to the filename 
                    else if (indexSEQ >= 0)
                    {
                        // Replace "#SEQ(XXX,XXX)" with the sequence string number
                        _currentChartImageLocation = GetNewSeqImageUrl(_currentChartImageLocation);
                    }

                }

                // Check if GUID parameter should be added to the SRC tag
                // Solves issue with image caching in IE
                int indexNoGuidParam = _currentChartImageLocation.IndexOf("#NOGUIDPARAM", StringComparison.Ordinal);
                if (indexNoGuidParam > 0)
                {
                    _currentChartImageLocation = _currentChartImageLocation.Replace("#NOGUIDPARAM", "");
                }

                // Check for virtual root character
                if (_currentChartImageLocation.StartsWith("~", StringComparison.Ordinal) && HttpContext.Current != null && this.Page.Request != null)
                {
                    // NOTE: Solves issue #4771
                    _currentChartImageLocation = this.Page.ResolveUrl(_currentChartImageLocation);
                }

                return _currentChartImageLocation;
            }
        }



        /// <summary>
        /// Determines if chart should render image maps
        /// </summary>
        /// <returns>True if should render image maps</returns>
        private bool HasImageMaps()
        {
            // Render chart image map
            if (this.RenderType != RenderType.BinaryStreaming && this.IsMapEnabled)
            {
                if (this.MapAreas.Count > 0 || this.RenderType == RenderType.ImageMap)
                {
                    // Render image map 
                    return true;
                }
            }
            return false;
        }
        
        /// <summary>
        /// Caches the IsImageRendersBorder result.
        /// </summary>
        private static int _isImageRendersBorder;
        /// <summary>
        /// Checks and returns true if the image renders border. Before Fx 4.0 image control renders border if is not declared. 
        /// After Fx 4.0 this is not by default.  
        /// </summary>
        /// <returns>True if image control renders border style</returns>
        private static bool IsImageRendersBorder
        {
            get
            {
                if (_isImageRendersBorder == 0)
                {
                    using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
                    {
                        using (HtmlTextWriter w = new HtmlTextWriter(sw))
                        {
                            System.Web.UI.WebControls.Image img = new System.Web.UI.WebControls.Image();
                            img.RenderControl(w);
                        }
                        _isImageRendersBorder = sw.ToString().IndexOf("border", 0, StringComparison.OrdinalIgnoreCase) != -1 ? 1 : -1;
                    }
                }
                return _isImageRendersBorder == 1;
            }
        }

        /// <summary>
        /// Custom image control for supporting miage maps.
        /// </summary>
        private class CustomImageControl : System.Web.UI.WebControls.Image
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="CustomImageControl"/> class.
            /// </summary>
            internal CustomImageControl() : base()
            {
            }

            /// <summary>
            /// Gets or sets a value indicating whether this instance has image map.
            /// </summary>
            /// <value>
            /// 	<c>true</c> if this instance has image map; otherwise, <c>false</c>.
            /// </value>
            internal bool HasImageMap { get; set; }

            /// <summary>
            /// Adds the attributes of an <see cref="T:System.Web.UI.WebControls.Image"/> to the output stream for rendering on the client.
            /// </summary>
            /// <param name="writer">A <see cref="T:System.Web.UI.HtmlTextWriter"/> that contains the output stream to render on the client browser.</param>
            protected override void AddAttributesToRender(HtmlTextWriter writer)
            {
                base.AddAttributesToRender(writer);
                if (this.HasImageMap)
                {
                    writer.AddAttribute(HtmlTextWriterAttribute.Usemap, "#"+this.ClientID+"ImageMap", false);
                }
                if (!this.Enabled)
                {
                    writer.AddAttribute(HtmlTextWriterAttribute.Disabled, "disabled");
                }
            }
        }

        /// <summary>
        /// Builds the image control.
        /// </summary>
        /// <param name="chartImageSrc">The chart image SRC.</param>
        /// <param name="addGuidParameter">if set to <c>true</c> to add GUID parameter.</param>
        /// <returns>A custom image control with image maps attribute</returns>
        private CustomImageControl BuildImageControl(string chartImageSrc, bool addGuidParameter)
        {
            CustomImageControl htmlImage = new CustomImageControl();
            htmlImage.ImageUrl = chartImageSrc + (addGuidParameter ? "?" + Guid.NewGuid().ToString() : "");
            htmlImage.ToolTip = this.ToolTip;
            htmlImage.CssClass = this.CssClass;
            htmlImage.AlternateText = this.AlternateText;
            htmlImage.DescriptionUrl = this.DescriptionUrl;
            htmlImage.AccessKey = this.AccessKey;
            htmlImage.TabIndex = this.TabIndex;
            htmlImage.Enabled = this.IsEnabled;
            htmlImage.CopyBaseAttributes(this);
            if (!IsImageRendersBorder)
            {
                // set border 0px only if is not declared yet.
                if ( String.IsNullOrEmpty(htmlImage.Style[HtmlTextWriterStyle.BorderWidth]) &&
                     String.IsNullOrEmpty(htmlImage.Style["border"]) &&
                     String.IsNullOrEmpty(htmlImage.Style["border-width"]))
                {
                    htmlImage.Style.Value = "border-width:0px;" + htmlImage.Style.Value;
                }
            }

            htmlImage.ID = this.ClientID;

            htmlImage.GenerateEmptyAlternateText = true;

            htmlImage.Width = this.Width;
            htmlImage.Height = this.Height;
            htmlImage.HasImageMap = this.HasImageMaps();

            return htmlImage;
        }

        private string _designTimeChart;
		/// <summary>
		/// Render this control to the output parameter specified.
		/// </summary>
        /// <param name="writer">HTML writer.</param>
        protected override void Render(HtmlTextWriter writer)
        {
            // If by any reason (rudimentary designer host, no designer, embeded in user control, etc) 
            // Render() is called in design mode ( should be handled by control designed )
            // we render the chart in temp file. 
            if (this.DesignMode)
            {
                if (String.IsNullOrEmpty(_designTimeChart))
                {
                    _designTimeChart = Path.GetTempFileName() + ".bmp";
                }
                SaveImage(_designTimeChart, ChartImageFormat.Bmp);
                using (CustomImageControl imageControl = this.BuildImageControl("file://" + _designTimeChart, false))
                {
                    imageControl.RenderControl(writer);
                }
                return;
            }

            // Check if GUID parameter should be added to the SRC tag
			// Solves issue with image caching in IE
			_addGuidParam = true;
			int		indexNoGuidParam = this.ImageLocation.IndexOf("#NOGUIDPARAM", StringComparison.Ordinal);
			if(indexNoGuidParam > 0)
			{
				_addGuidParam = false;
			}

			// Get picture name
			string	chartImage = this.CurrentImageLocation;


            if (this.RenderType == RenderType.ImageTag)
            {
                if (this.GetImageStorageMode() == ImageStorageMode.UseHttpHandler)
                {
                    using (MemoryStream stream = new MemoryStream())
                    {
                        this.SaveImage(stream);
                        chartImage = ChartHttpHandler.GetChartImageUrl(stream, this.ImageType.ToString());
                        _currentChartHandlerImageLocation = chartImage;
                    }
                    _addGuidParam = false;
                }
                else
                {
                    // Save chart into specified image URL
                    SaveImage(this.Page.MapPath(chartImage));
                }

                using (CustomImageControl imageControl = this.BuildImageControl(chartImage, _addGuidParam))
                {
                    imageControl.RenderControl(writer);
                }
                
			}

			// Render chart image as image tag + image map
			else if(this.RenderType == RenderType.ImageMap)
			{

				// Get chart image (do not save it)
                chartPicture.PaintOffScreen();

                using (CustomImageControl imageControl = this.BuildImageControl(chartImage, _addGuidParam))
                {
                    imageControl.RenderControl(writer);
                }

	        }
            // Render chart using binary data streaming
            else
            {

                // Set response content type
                switch (chartPicture.ImageType)
                {
                    case (ChartImageType.Bmp):
                        this.Page.Response.ContentType = "image/bmp";
                        break;
                    case (ChartImageType.Jpeg):
                        this.Page.Response.ContentType = "image/jpeg";
                        break;
                    case (ChartImageType.Png):
                        this.Page.Response.ContentType = "image/png";
                        break;
                }

                this.Page.Response.Charset = "";

                // Save image into the memory stream
                MemoryStream stream = new MemoryStream();
                SaveImage(stream);
                this.Page.Response.BinaryWrite(stream.GetBuffer());
            }


			// Render chart image map
            if (this.HasImageMaps())
			{
					// Render image map 
					chartPicture.WriteChartMapTag(writer, this.ClientID + "ImageMap");
			}

            // Reset image Url field
            this._currentChartImageLocation = String.Empty;

		}


        /// <summary>
		/// Checks image URL sequence format.
		/// </summary>
		/// <param name="imageURL">Image URL to test.</param>
		void CheckImageURLSeqFormat(string imageURL)
		{
			// Find the begginning of the "#SEQ" formatting string
			int indexSEQ = imageURL.IndexOf("#SEQ", StringComparison.Ordinal);
			indexSEQ += 4;

			// The "#SEQ" formatter must be followed by (MMM,TTT), where MMM - max sequence number and TTT - time to live
			if(imageURL[indexSEQ] != '(')
			{
				throw( new ArgumentException(SR.ExceptionImageUrlInvalidFormat, "imageURL"));
			}
			// Find closing bracket
			int indexClosing = imageURL.IndexOf(')', 1);
			if(indexClosing < 0)
			{
                throw (new ArgumentException(SR.ExceptionImageUrlInvalidFormat, "imageURL"));
			}

			// Get max sequence number and time to live
			string[] values = imageURL.Substring(indexSEQ + 1, indexClosing - indexSEQ - 1).Split(',');
			if(values == null || values.Length != 2)
			{
                throw (new ArgumentException(SR.ExceptionImageUrlInvalidFormat, "imageURL"));
			}

			// Make sure all characters are digits
			foreach(String str in values)
			{
                if (String.IsNullOrEmpty(str) || str.Length > 7)
                {
                    throw (new ArgumentException(SR.ExceptionImageUrlInvalidFormat, "imageURL"));
                }
                foreach (Char c in str)
				{
					if(!Char.IsDigit(c))
					{
						throw( new ArgumentException( SR.ExceptionImageUrlInvalidFormat, "imageURL"));
					}
				}
			}
		}

		/// <summary>
		/// Helper function, which returns a new image URL 
		/// using the sequence numbers
		/// </summary>
		/// <param name="imageUrl">Image URL format.</param>
		/// <returns>New image URL.</returns>
		private string GetNewSeqImageUrl(string imageUrl)
		{
			// Initialize image URL max sequence number and image time to live values
			int		maxSeqNumber = 0;
			int		imageTimeToLive = 0;
			string	result = "";

			//*********************************************************
			//** Check image URL format
			//*********************************************************

			// Find the begginning of the "#SEQ" formatting string
			int indexSEQ = imageUrl.IndexOf("#SEQ", StringComparison.Ordinal);
			if(indexSEQ < 0)
			{
				throw( new ArgumentException( SR.ExceptionImageUrlMissedFormatter, "imageUrl"));
			}

			// Check format
			CheckImageURLSeqFormat(imageUrl);

			// Copy everything till the beginning of the format in the result string
			result = imageUrl.Substring(0, indexSEQ);
			indexSEQ += 4;

			// Find closing bracket
			int indexClosing = imageUrl.IndexOf(')', 1);

			// Add sequence position and everything after closing bracket into the result string
			result += "{0:D6}";
			result += imageUrl.Substring(indexClosing + 1);

			// Get max sequence number and time to live
			string[] values = imageUrl.Substring(indexSEQ + 1, indexClosing - indexSEQ - 1).Split(',');
			maxSeqNumber = Int32.Parse(values[0], System.Globalization.CultureInfo.InvariantCulture);
			imageTimeToLive = Int32.Parse(values[1], System.Globalization.CultureInfo.InvariantCulture);

			//*********************************************************
			//** Generate new sequence number
			//*********************************************************
			int		imageSeqNumber = 1;

			// Make sure application scope variable "ImageSeqNumber" exist
			this.Page.Application.Lock();
			if(this.Page.Application[Chart.productID+"_ImageSeqNumber"] != null)
			{
				imageSeqNumber = (int)this.Page.Application[Chart.productID+"_ImageSeqNumber"] + 1;
				if(imageSeqNumber > maxSeqNumber)
				{
					imageSeqNumber = 1;
				}
			}
			// Save sequence number
			this.Page.Application[Chart.productID+"_ImageSeqNumber"] = imageSeqNumber;
			this.Page.Application.UnLock();

			//*********************************************************
			//** Prepare result string
			//*********************************************************

			result = String.Format(CultureInfo.InvariantCulture, result, imageSeqNumber);

			//*********************************************************
			//** Check if the image with this name exsists and it's
			//** live time is smaller than image time-to-live specified.
			//** In this case put a warning into the even log.
			//*********************************************************
			if(imageTimeToLive > 0)
			{
				CheckChartFileTime(result, imageTimeToLive);
			}

			return result;
		}

		/// <summary>
		/// Check if the image with this name exsists and it's
		/// live time is smaller than image time-to-live specified.
		/// In this case put a warning into the even log.
		/// </summary>
		/// <param name="fileName">File name.</param>
		/// <param name="imageTimeToLive">Time to live.</param>
		private void CheckChartFileTime(string fileName, int imageTimeToLive)
		{
			//*********************************************************
			//** Check if the image with this name exsists and it's
			//** live time is smaller than image time-to-live specified.
			//** In this case put a warning into the even log.
			//*********************************************************
            try
            {
                if (imageTimeToLive > 0)
                {
                    fileName = this.Page.MapPath(fileName);
                    if (File.Exists(fileName))
                    {
                        DateTime fileTime = File.GetLastWriteTime(fileName);
                        if (fileTime.AddMinutes(imageTimeToLive) > DateTime.Now)
                        {
                            const string eventSource = "ChartComponent";

                            // Create the source, if it does not already exist.
                            if (!EventLog.SourceExists(eventSource))
                            {
                                EventLog.CreateEventSource(eventSource, "Application");
                            }

                            // Create an EventLog instance and assign its source.
                            EventLog eventLog = new EventLog();
                            eventLog.Source = eventSource;

                            // Write an informational entry to the event log.    
                            TimeSpan timeSpan = DateTime.Now - fileTime;
                            eventLog.WriteEntry(SR.EvenLogMessageChartImageFileTimeToLive(timeSpan.Minutes.ToString(CultureInfo.InvariantCulture)), EventLogEntryType.Warning);
                        }
                    }
                }
            }
            catch (SecurityException)
            {
            }
            catch (ArgumentException)
            {
            }
            catch (InvalidOperationException)
            {
            }
            catch (Win32Exception)
            {
            }
		}

		#endregion

		#region Chart selection methods

        /// <summary>
        /// This method performs the hit test and returns a HitTestResult objects.
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        /// <returns>Hit test result object</returns>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public HitTestResult HitTest(int x, int y)
        {
            return selection.HitTest(x, y);
        }

        /// <summary>
        /// This method performs the hit test and returns a HitTestResult object.
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        /// <param name="ignoreTransparent">Indicates that transparent elements should be ignored.</param>
        /// <returns>Hit test result object</returns>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public HitTestResult HitTest(int x, int y, bool ignoreTransparent)
        {
            return selection.HitTest(x, y, ignoreTransparent);
        }

        /// <summary>
        /// This method performs the hit test and returns a HitTestResult object.
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        /// <param name="requestedElement">Only this chart element will be hit tested.</param>
        /// <returns>Hit test result object</returns>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public HitTestResult HitTest(int x, int y, ChartElementType requestedElement)
        {
            return selection.HitTest(x, y, requestedElement);
        }

        /// <summary>
        /// Call this method to determine the  chart element,
        /// if any, that is located at a point defined by the given X and Y 
        /// coordinates.
        /// <seealso cref="HitTestResult"/></summary>
        /// <param name="x">The X coordinate for the point in question.
        /// Often obtained from a parameter in an event
        /// (e.g. the X parameter value in the MouseDown event).</param>
        /// <param name="y">The Y coordinate for the point in question.
        /// Often obtained from a parameter in an event
        /// (e.g. the Y parameter value in the MouseDown event).</param>
        /// <param name="ignoreTransparent">Indicates that transparent 
        /// elements should be ignored.</param>
        /// <param name="requestedElement">
        /// An array of type which specify the types                  
        /// to test for, on order to filter the result. If omitted checking for                 
        /// elementTypes will be ignored and all kind of elementTypes will be 
        /// valid.
        ///  </param>
        /// <returns>
        /// A array of <see cref="HitTestResult"/> objects,
        /// which provides information concerning the  chart element
        /// (if any) that is at the specified location. Result contains at least
        /// one element, which could be ChartElementType.Nothing. 
        /// The objects in the result are sorted in from top to bottom of 
        /// different layers of control. </returns>
        /// <remarks>Call this method to determine the  gauge element
        /// (if any) that is located at a specified point. Often this method is used in
        /// some mouse-related event (e.g. MouseDown)
        /// to determine what  gauge element the end-user clicked on.
        /// The X and Y mouse coordinates obtained from the
        /// event parameters are then used for the X and Y parameter              
        /// values of this method call.   The returned 
        /// <see cref="HitTestResult"/> object's properties
        /// can then be used to determine what  chart element was clicked on,
        /// and also provides a reference to the actual object selected (if 
        /// any).</remarks>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public HitTestResult[] HitTest(int x, int y, bool ignoreTransparent, params ChartElementType[] requestedElement)
        {
            return this.selection.HitTest(x, y, ignoreTransparent, requestedElement);
        }

        /// <summary>
        /// Gets the chart element outline.
        /// </summary>
        /// <param name="chartElement">The chart element.</param>
        /// <param name="elementType">Type of the element.</param>
        /// <returns> A <see cref="ChartElementOutline"/> object which contains
        /// 1) An array of points in absolute coordinates which can be used as outline markers arround this chart element.
        /// 2) A GraphicsPath for drawing aouline around this chart emenent.
        /// </returns>
        /// <remarks>
        /// If the <paramref name="chartElement"/> is not part of the chart or <paramref name="elementType"/> cannot be combined 
        /// with <paramref name="chartElement"/> then the result will contain empty array of marker points. 
        /// The marker points are sorted clockwise.
        /// </remarks>
        public ChartElementOutline GetChartElementOutline(object chartElement, ChartElementType elementType)
        {
            return this.selection.GetChartElementOutline(chartElement, elementType);
        }

		#endregion

		#region Chart image saving methods

        /// <summary>
        /// Draws chart on the graphics.
        /// </summary>
        /// <param name="graphics">Graphics.</param>
        /// <param name="position">Position to draw in the graphics.</param>
        public void Paint(Graphics graphics, Rectangle position)
        {
                // Change chart size to fit the new position
                int oldWidth = this.chartPicture.Width;
                int oldHeight = this.chartPicture.Height;
                // Save graphics state.
                GraphicsState transState = graphics.Save();
                try
                {
                    this.chartPicture.Width = position.Width;
                    this.chartPicture.Height = position.Height;
                    // Set required transformation
                    graphics.TranslateTransform(position.X, position.Y);
                    // Set printing indicator
                    this.chartPicture.isPrinting = true;
                    // Draw chart
                    this.chartPicture.Paint(graphics, false);
                    // Clear printing indicator
                    this.chartPicture.isPrinting = false;

                }
                finally
                {
                    // Restore graphics state.
                    graphics.Restore(transState);
                    // Restore old chart position
                    this.chartPicture.Width = oldWidth;
                    this.chartPicture.Height = oldHeight;

                }
        }
		
        /// <summary>
		/// Saves chart image into the file.
		/// </summary>
		/// <param name="imageFileName">Image file name</param>
		/// <param name="format">Image format.</param>
		public void SaveImage(string imageFileName, ChartImageFormat format)
        {
            // Check arguments
            if (imageFileName == null)
                throw new ArgumentNullException("imageFileName");

			// Create file stream for the specified file name
			FileStream	fileStream = new FileStream(imageFileName, FileMode.Create);

			// Save into stream
			try 
			{
				SaveImage(fileStream, format);
			}
			finally
			{
				// Close file stream
				fileStream.Close();
			}
		}


		/// <summary>
		/// Saves chart image into the stream.
		/// </summary>
		/// <param name="imageStream">Image stream.</param>
		/// <param name="format">Image format.</param>
		public void SaveImage( Stream imageStream, ChartImageFormat format)
		{
            // Check arguments
            if (imageStream == null)
                throw new ArgumentNullException("imageStream");

            this.chartPicture.isPrinting = true;
            try
            {
                if (format == ChartImageFormat.Emf ||
                    format == ChartImageFormat.EmfDual ||
                    format == ChartImageFormat.EmfPlus)
                {
                    EmfType emfType = EmfType.EmfOnly;
                    if (format == ChartImageFormat.EmfDual)
                    {
                        emfType = EmfType.EmfPlusDual;
                    }
                    else if (format == ChartImageFormat.EmfPlus)
                    {
                        emfType = EmfType.EmfPlusOnly;
                    }

                    // Save into the metafile
                    this.chartPicture.SaveIntoMetafile(imageStream, emfType);
                }
                else
                {
                    // Get chart image
                    System.Drawing.Image chartImage = this.chartPicture.GetImage();
                    
                    ImageFormat standardImageFormat = ImageFormat.Png;

                    switch (format)
                    {
                        case ChartImageFormat.Bmp:
                            standardImageFormat = ImageFormat.Bmp;
                            break;

                        case ChartImageFormat.Gif:
                            standardImageFormat = ImageFormat.Gif;
                            break;
                        
                       case ChartImageFormat.Tiff:
                            standardImageFormat = ImageFormat.Tiff;
                            break;


                        case ChartImageFormat.Jpeg:
                            standardImageFormat = ImageFormat.Jpeg;
                            break;
                        case ChartImageFormat.Png:
                            standardImageFormat = ImageFormat.Png;
                            break;

                        
                        case ChartImageFormat.Emf:
                            standardImageFormat = ImageFormat.Emf;
                            break;
                    }

                    // Save image into the file
                    chartImage.Save(imageStream, standardImageFormat);

                    // Dispose image
                    chartImage.Dispose();
                }
            }
            finally
            {
                this.chartPicture.isPrinting = false;
            }
		}


		/// <summary>
		/// Saves image into the stream. ImageType, Compression and other control properties are used.
		/// </summary>
		/// <param name="imageStream">Image stream.</param>
        public void SaveImage(Stream imageStream)
		{
            // Check arguments
            if (imageStream == null)
                throw new ArgumentNullException("imageStream");

			//*****************************************************
			//** Disable validating the license for now....
			//*****************************************************
			// ValidateLicense();

            this.chartPicture.isPrinting = true;
            try
            {

			// Save into the metafile
			if( ImageType == ChartImageType.Emf)
			{
				this.chartPicture.SaveIntoMetafile(imageStream, EmfType.EmfOnly);
				return;
			}

            System.Drawing.Image image = chartPicture.GetImage();
            // Set image settings
			ImageCodecInfo imageCodecInfo = null;
			EncoderParameter encoderParameter = null;
			EncoderParameters encoderParameters = new EncoderParameters(1);

			// Get image codec information
			if(ImageType == ChartImageType.Bmp)
			{
				imageCodecInfo = GetEncoderInfo("image/bmp");
			}
			else if(ImageType == ChartImageType.Jpeg)
			{
				imageCodecInfo = GetEncoderInfo("image/jpeg");
			}
			else if(ImageType == ChartImageType.Png)
			{
				imageCodecInfo = GetEncoderInfo("image/png");
			}

			// Set image quality
			encoderParameter = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100-Compression);
			encoderParameters.Param[0] = encoderParameter;

			// Save image into the file
			if(imageCodecInfo == null)
			{
				ImageFormat	format = (ImageFormat)new ImageFormatConverter().ConvertFromString(ImageType.ToString());
				image.Save(imageStream, format);
			}
			else
			{
				image.Save(imageStream, imageCodecInfo, encoderParameters);
			}

			image.Dispose();
        }
        finally
        {
            this.chartPicture.isPrinting = false;
        }
    }

			
		/// <summary>
		/// Saves image into the file. ImageType, Compression and other control properties are used.
		/// </summary>
		/// <param name="imageFileName">Image file name</param>
		public void SaveImage(string imageFileName)
		{
            // Check arguments
            if (imageFileName == null)
                throw new ArgumentNullException("imageFileName");

			// Create file stream for the specified file name
			FileStream	fileStream = new FileStream(imageFileName, FileMode.Create);

			// Save into stream
			try 
			{
				SaveImage(fileStream);
			}
			finally
			{
				// Close file stream
				fileStream.Close();
			}
		}





		/// <summary>
		/// Helper function. Returns image encoder using Mime image type
		/// </summary>
		/// <param name="mimeType">Mime image type</param>
		/// <returns>Image codec</returns>
		private static ImageCodecInfo GetEncoderInfo(String mimeType)
		{
			int j;
			ImageCodecInfo[] encoders;
			encoders = ImageCodecInfo.GetImageEncoders();
			for(j = 0; j < encoders.Length; ++j)
			{
				if(encoders[j].MimeType == mimeType)
				{
					return encoders[j];
				}
			}
			return null;
		}

#endregion

		#region Control events


        // Defines a key for storing the delegate for the PrePaint event
        // in the Events list.
        private static readonly object _prePaintEvent = new object();

		/// <summary>
		/// Fires after the chart element backround was drawn. 
		/// This event is fired for elements like: ChartPicture, ChartArea and Legend
		/// </summary>
		[
		SRDescription("DescriptionAttributeChartEvent_PrePaint")
		]
        public event EventHandler<ChartPaintEventArgs> PrePaint
        {
            add { Events.AddHandler(_prePaintEvent, value); }
            remove { Events.RemoveHandler(_prePaintEvent, value); }
        }

        // Defines a key for storing the delegate for the PrePaint event
        // in the Events list.
        private static readonly object _postPaintEvent = new object();

		/// <summary>
		/// Fires after chart element was drawn. 
		/// This event is fired for elements like: ChartPicture, ChartArea and Legend
		/// </summary>
        [
        SRDescription("DescriptionAttributeChartEvent_PostPaint")
        ]
        public event EventHandler<ChartPaintEventArgs> PostPaint
        {
            add { Events.AddHandler(_postPaintEvent, value); }
            remove { Events.RemoveHandler(_postPaintEvent, value); }
        }

        // Defines a key for storing the delegate for the CustomizeMapAreas event
        // in the Events list.
        private static readonly object _customizeMapAreasEvent = new object();

		/// <summary>
		/// Fires just before the chart image map is rendered. Use this event to customize the map areas items.
		/// </summary>
		[
		SRDescription("DescriptionAttributeChartEvent_CustomizeMapAreas")
		]
        public event EventHandler<CustomizeMapAreasEventArgs> CustomizeMapAreas
        {
            add { Events.AddHandler(_customizeMapAreasEvent, value); }
            remove { Events.RemoveHandler(_customizeMapAreasEvent, value); }
        }



        // Defines a key for storing the delegate for the CustomizeMapAreas event
        // in the Events list.
        private static readonly object _customizeEvent = new object();
        /// <summary>
		/// Fires just before the chart image is drawn. Use this event to customize the chart picture.
		/// </summary>
		[
		SRDescription("DescriptionAttributeChartEvent_Customize")
		]
		public event EventHandler Customize
        {
            add { Events.AddHandler(_customizeEvent, value); }
            remove { Events.RemoveHandler(_customizeEvent, value); }
        }

        // Defines a key for storing the delegate for the CustomizeMapAreas event
        // in the Events list.
        private static readonly object _customizeLegendEvent = new object();
        /// <summary>
		/// Fires just before the chart legend is drawn. Use this event to customize the chart legend items.
		/// </summary>
        [
        SRDescription("DescriptionAttributeChartEvent_CustomizeLegend")
        ]
        public event EventHandler<CustomizeLegendEventArgs> CustomizeLegend
        {
            add { Events.AddHandler(_customizeLegendEvent, value); }
            remove { Events.RemoveHandler(_customizeLegendEvent, value); }
        }

        // Defines a key for storing the delegate for the Click event
        // in the Events list.
        private static readonly object _clickEvent = new object();
        /// <summary>
        /// Occurs when active image map area defined by PostBackValue on Chart control is clicked.
        /// </summary>
        [
        SRCategory("CategoryAttributeAction"),
        SRDescription(SR.Keys.DescriptionAttributeChartEvent_Click)
        ]
        public event ImageMapEventHandler Click
        {
            add { Events.AddHandler(_clickEvent, value); }
            remove { Events.RemoveHandler(_clickEvent, value); }
        }


		#endregion

		#region Event Handling

      
		/// <summary>
		/// Invokes delegates registered with the Click event.
		/// </summary>
		/// <param name="e"></param>
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnClick(ImageMapEventArgs e) 
		{
            ImageMapEventHandler clickEventDelegate = (ImageMapEventHandler)Events[_clickEvent];
			if (clickEventDelegate != null) 
			{
				clickEventDelegate(this, e);
			}  
		}
      
        
		/// <summary>
        /// Raises events for the Chart control when a form is posted back to the server.
		/// </summary>
		/// <param name="eventArgument">Event argument.</param>
        [SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate")]
		protected virtual void RaisePostBackEvent(string eventArgument)
		{
            if (!String.IsNullOrEmpty(eventArgument))
            {
                this.OnClick(new ImageMapEventArgs(eventArgument));
            }
		}

		/// <summary>
		/// Fires when chart element backround must be drawn. 
		/// This event is fired for elements like: ChatPicture, ChartArea and Legend
		/// </summary>
		/// <param name="e">Event arguments.</param>
		[
		SRDescription("DescriptionAttributeChart_OnBackPaint")
		]
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnPrePaint(ChartPaintEventArgs e) 
		{
            EventHandler<ChartPaintEventArgs> prePaintEventDelegate = (EventHandler<ChartPaintEventArgs>)Events[_prePaintEvent];
            if (prePaintEventDelegate != null)
            {
                prePaintEventDelegate(this, e);
            }  
		}

        /// <summary>
        /// Fires when chart element backround must be drawn. 
        /// This event is fired for elements like: ChatPicture, ChartArea and Legend
        /// </summary>
        /// <param name="e">Event arguments.</param>
        internal void CallOnPrePaint(ChartPaintEventArgs e)
        {
            this.OnPrePaint(e);
        }

		/// <summary>
		/// Fires when chart element must be drawn. 
		/// This event is fired for elements like: ChatPicture, ChartArea and Legend
		/// </summary>
		/// <param name="e">Event arguments.</param>
		[
		SRDescription("DescriptionAttributeChart_OnPaint")
		]
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnPostPaint(ChartPaintEventArgs e) 
		{
            EventHandler<ChartPaintEventArgs> postPaintEventDelegate = (EventHandler<ChartPaintEventArgs>)Events[_postPaintEvent];
            if (postPaintEventDelegate != null)
            {
                postPaintEventDelegate(this, e);
            }  
		}

        /// <summary>
        /// Fires when chart element must be drawn. 
        /// This event is fired for elements like: ChatPicture, ChartArea and Legend
        /// </summary>
        /// <param name="e">Event arguments.</param>
        internal void CallOnPostPaint(ChartPaintEventArgs e)
        {
            this.OnPostPaint(e);
        }

        /// <summary>
        /// Fires when chart image map data is prepared to be rendered.
        /// </summary>
        /// <param name="e">The <see cref="System.Web.UI.DataVisualization.Charting.CustomizeMapAreasEventArgs"/> instance containing the event data.</param>
		[
		SRDescription("DescriptionAttributeChart_OnCustomizeMapAreas")
		]
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnCustomizeMapAreas(CustomizeMapAreasEventArgs e) 
		{
            EventHandler<CustomizeMapAreasEventArgs> customizeMapAreasEventDelegate = (EventHandler<CustomizeMapAreasEventArgs>)Events[_customizeMapAreasEvent];
            if (customizeMapAreasEventDelegate != null)
            {
                customizeMapAreasEventDelegate(this, e);
            }  
		}

        /// <summary>
        /// Fires when chart image map data is prepared to be rendered.
        /// </summary>
        internal void CallOnCustomizeMapAreas(MapAreasCollection areaItems)
        {
            this.OnCustomizeMapAreas(new CustomizeMapAreasEventArgs(areaItems));
        }

        /// <summary>
        /// Fires when all chart data is prepared to be customized before drawing.
        /// </summary>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
		[
		SRDescription("DescriptionAttributeChart_OnCustomize")
		]
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnCustomize(EventArgs e) 
		{
            EventHandler customizeEventDelegate = (EventHandler)Events[_customizeEvent];
            if (customizeEventDelegate != null)
            {
                customizeEventDelegate(this, e);
            }  
		}

		/// <summary>
		/// Fires when all chart legend data is prepared to be customized before drawing.
		/// </summary>
		[
		SRDescription("DescriptionAttributeChart_OnCustomizeLegend")
		]
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
        protected virtual void OnCustomizeLegend(CustomizeLegendEventArgs e) 
		{
            EventHandler<CustomizeLegendEventArgs> customizeLegendEventDelegate = (EventHandler<CustomizeLegendEventArgs>)Events[_customizeLegendEvent];
            if (customizeLegendEventDelegate != null)
            {
                customizeLegendEventDelegate(this, e);
            }  
		}

		/// <summary>
		/// Event firing helper function.
		/// </summary>
		internal void CallOnCustomize() 
		{
            OnCustomize(EventArgs.Empty);
		}

		/// <summary>
		/// Event firing helper function.
		/// </summary>
		internal void CallOnCustomizeLegend(LegendItemsCollection legendItems, string legendName) 
		{
            OnCustomizeLegend(new CustomizeLegendEventArgs(legendItems, legendName));
		}

		#endregion

		#region View state properties and methods


		/// <summary>
		/// Restores view-state information from a previous page request that was saved by the SaveViewState method.
		/// </summary>
		/// <param name="savedState">An Object that represents the control state to be restored.</param>
		protected override void LoadViewState(object savedState)
		{
            // Call the base class
            base.LoadViewState(savedState);

			// Check if view state is enabled
			if(this.EnableViewState)
			{

                // Load chart's data if custom user state data was not set
				if(this.ViewState["ViewStateData"] != null &&
					(this.ViewState["CustomUserViewStateData"] == null ||
					((string)this.ViewState["CustomUserViewStateData"]) == "false"))
				{
					// Set serializable content
					SerializationContents  oldContent = this.Serializer.Content;
					string oldSerializable = this.Serializer.SerializableContent;
					string oldNonSerializable = this.Serializer.NonSerializableContent;
					SerializationFormat oldFormat = this.Serializer.Format;
					this.Serializer.Content = this.ViewStateContent;
					this.Serializer.Format = SerializationFormat.Xml;

					// Load data in the chart from the view state
					StringReader stringReader = new StringReader((string)this.ViewState["ViewStateData"]);

					this.Serializer.Load(stringReader);

					// Remove chart data from view state
					this.ViewState.Remove("ViewStateData");

					// Restore serializable content
					this.Serializer.Format = oldFormat;
					this.Serializer.Content = oldContent;
					this.Serializer.SerializableContent = oldSerializable;
					this.Serializer.NonSerializableContent = oldNonSerializable;
				}
			}
		}

		/// <summary>
		/// Saves any server control view-state changes that have occurred since the time the page was posted back to the server.
		/// </summary>
		/// <returns>Returns the server control's current view state. </returns>
		protected override object SaveViewState()
		{
            // Check if view state is enabled
			if(base.EnableViewState)
			{
				// Save chart's data if custom user state data was not set
				if(this.ViewState["ViewStateData"] == null)
				{
					// Set serializable content
					SerializationContents  oldContent = this.Serializer.Content;
					string oldSerializable = this.Serializer.SerializableContent;
					string oldNonSerializable = this.Serializer.NonSerializableContent;
					this.Serializer.Content = this.ViewStateContent;

					// Save data from the chart into the view state
					StringBuilder stringBuilder = new StringBuilder();
					StringWriter stringWriter = new StringWriter(stringBuilder, CultureInfo.InvariantCulture);
					this.Serializer.Save(stringWriter);

					// Put data in view state
					this.ViewState["ViewStateData"] = (string)stringBuilder.ToString();

					// Remove chart user custom view state flag
					this.ViewState.Remove("CustomUserViewStateData");

					// Restore serializable content
					this.Serializer.Content = oldContent;
					this.Serializer.SerializableContent = oldSerializable;
					this.Serializer.NonSerializableContent = oldNonSerializable;
				}
                // Call base class
            }
            return base.SaveViewState();
		}



		/// <summary>
		/// Gets or sets a value indicating whether the control persists its view state.
		/// </summary>
		[
		SRCategory("CategoryAttributeViewState"),
		Bindable(true),
		SRDescription("DescriptionAttributeChart_EnableViewState"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
		DefaultValue(false)
		]
		public override bool EnableViewState
		{
			get
			{
                return base.EnableViewState;
			}
			set
			{
				base.EnableViewState = value;
			}
		}



		/// <summary>
		/// Chart content saved in the view state.
		/// </summary>
		[
		SRCategory("CategoryAttributeBehavior"),
		Bindable(true),
		DefaultValue(typeof(SerializationContents ), "Default"),
		SRDescription("DescriptionAttributeChart_ViewStateContent"),
        Editor(Editors.FlagsEnumUITypeEditor.Editor, Editors.FlagsEnumUITypeEditor.Base)
		]
		public SerializationContents  ViewStateContent
		{
			get
			{
				return _viewStateContent;
			}
			set
			{
                int result = 0;
                if (Int32.TryParse(value.ToString(), out result))
                {
                    throw new ArgumentException(SR.ExceptionEnumInvalid(value.ToString()));
                }
                _viewStateContent = value;
			}
		}

		/// <summary>
		/// User defined control state data in XML format.
		/// </summary>
		[
		SRCategory("CategoryAttributeViewState"),
        Browsable(false),
        Obsolete("ViewStateData has been deprecated. Please investigate Control.ViewState instead."),
		Bindable(true),
		DefaultValue(""),
		SRDescription("DescriptionAttributeChart_ViewStateData"),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Never) 
		]
		public string ViewStateData
		{
			get
			{
				return (string)this.ViewState["ViewStateData"];
			}
			set
			{
				// Set state data
				this.ViewState["ViewStateData"] = value;

				// Set custom user state data indicator
				this.ViewState["CustomUserViewStateData"] = "true";
			}
		}


		#endregion

		#region Control properties



		/// <summary>
		/// Indicates that non-critical chart exceptions will be suppressed.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(false),
		SRDescription("DescriptionAttributeSuppressExceptions"),
		]
		public bool SuppressExceptions
		{
			set
			{
				this.chartPicture.SuppressExceptions = value;
			}
			get
			{
				return this.chartPicture.SuppressExceptions;
			}
		}



		/// <summary>
		/// Chart named images collection.
		/// </summary>
		[
		SRCategory("CategoryAttributeChart"),
		Bindable(false),
		SRDescription("DescriptionAttributeChart_Images"),
		Browsable(false),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        , EditorBrowsable(EditorBrowsableState.Never)
		]
		public NamedImagesCollection Images
		{
			get
			{
				return _namedImages;
			}
		}

        /// <summary>
		/// Font property is not used.
		/// </summary>
		[
		Browsable(false),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden)
		]
		public override FontInfo Font
		{
			get
			{
				return base.Font;
			}
		}

        /// <summary>
		/// Chart rendering type. Image tag, input tag, binary data streaming and image map are the options.
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		SRDescription("DescriptionAttributeChart_RenderType"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
		DefaultValue(RenderType.ImageTag)
		]
		public RenderType RenderType
		{
			get
			{
				return _renderType;
			}
			set
			{
				_renderType = value;

				if(_renderType == RenderType.ImageMap && this.IsMapEnabled == false)
				{
					this.IsMapEnabled = true;
				}
			}
		}



        /// <summary>
		/// Location where chart image is saved, when image tag is used for rendering.
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		SRDescription("DescriptionAttributeChart_ImageUrl"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
		DefaultValue("ChartPic_#SEQ(300,3)"),
        Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base)
		]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings")]
		public string ImageLocation
		{
			get
			{
				return _chartImageLocation;
			}
			set
			{
				// Find the begginning of the "#SEQ" formatting string
				int indexSEQ = value.IndexOf("#SEQ", StringComparison.Ordinal);
				if(indexSEQ > 0)
				{
					// Check format
					CheckImageURLSeqFormat(value);
				}
				_chartImageLocation = value;
			}
		}

        // VSTS 96787-Text Direction (RTL/LTR)

        /// <summary>
        /// Indicates whether the control should draw right-to-left for RTL languages.
        /// <seealso cref="AntiAliasing"/>
        /// </summary>
        /// <value>
        /// One of the <see cref="System.Windows.Forms.RightToLeft"/> values. The default is
        /// <b>RightToLeft.No</b>.
        /// </value>
        /// <remarks>This property affects the direction of legend color keys.</remarks>
        [
        Category("Appearance"),
        SRDescription("DescriptionAttributeRightToLeft"),
        PersistenceMode(PersistenceMode.Attribute),
        DefaultValue(RightToLeft.No)
        ]
        public RightToLeft RightToLeft
        {
            get
            {
                return this.chartPicture.RightToLeft;
            }
            set
            {
                this.chartPicture.RightToLeft = value;
            }
        }

		#endregion

		#region Data Manager Properties

		/// <summary>
		/// Chart series collection.
		/// </summary>
		[
        SRCategory("CategoryAttributeChart"),
		SRDescription("DescriptionAttributeChart_Series"),
		PersistenceModeAttribute(PersistenceMode.InnerProperty),
        Editor(Editors.SeriesCollectionEditor.Editor, Editors.SeriesCollectionEditor.Base),
#if !Microsoft_CONTROL
        Themeable(false)
#endif 
		]
		public SeriesCollection Series
		{
			get
			{
				return _dataManager.Series;
			}
		}

		/// <summary>
		/// Color palette to use
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		SRDescription("DescriptionAttributePalette"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
        DefaultValue(ChartColorPalette.BrightPastel),
        Editor(Editors.ColorPaletteEditor.Editor, Editors.ColorPaletteEditor.Base)
		]
		public ChartColorPalette Palette
		{
			get
			{
				return _dataManager.Palette;
			}
			set
			{
				_dataManager.Palette = value;
			}
		}



		/// <summary>
		/// Array of custom palette colors.
		/// </summary>
		/// <remarks>
		/// When this custom colors array is non-empty the <b>Palette</b> property is ignored.
		/// </remarks>
		[
		SRCategory("CategoryAttributeAppearance"),
		SerializationVisibilityAttribute(SerializationVisibility.Attribute),
		SRDescription("DescriptionAttributeChart_PaletteCustomColors"),
		TypeConverter(typeof(ColorArrayConverter))
		]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
		public Color[] PaletteCustomColors
		{
			set
			{
				this._dataManager.PaletteCustomColors = value;
			}
			get
			{
				return this._dataManager.PaletteCustomColors;
			}
		}

		/// <summary>
		/// Method resets custom colors array. Internal use only.
		/// </summary>
		[EditorBrowsable(EditorBrowsableState.Never)]
		internal void ResetPaletteCustomColors()
		{
			this.PaletteCustomColors = new Color[0];
		}

		/// <summary>
		/// Method resets custom colors array. Internal use only.
		/// </summary>
		[EditorBrowsable(EditorBrowsableState.Never)]
        internal bool ShouldSerializePaletteCustomColors()
		{
			if(this.PaletteCustomColors == null ||
				this.PaletteCustomColors.Length == 0)
			{
				return false;
			}
			return true;
		}



		#endregion

		#region Chart Properties


		/// <summary>
		/// "The data source used to populate series data. Series ValueMember properties must be also set."
		/// </summary>
		[
		SRCategory("CategoryAttributeData"),
		Bindable(true),
		SRDescription("DescriptionAttributeDataSource"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
		DefaultValue(null),
		TypeConverter(typeof(ChartDataSourceConverter)),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden)
		]
		public override object DataSource
		{
			get
			{
				return base.DataSource;
			}
			set
			{
                base.DataSource = value;
				chartPicture.DataSource = value;
			}
		}

		/// <summary>
		/// Build number of the control
		/// </summary>
		[
		SRDescription("DescriptionAttributeChart_BuildNumber"),
		Browsable(false),
		EditorBrowsable(EditorBrowsableState.Never),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
		DefaultValue("")
		]
		public string BuildNumber
		{
			get
			{
				// Get build number from the assembly
				string	buildNumber = String.Empty;
				Assembly assembly = Assembly.GetExecutingAssembly();
				if(assembly != null)
				{
					buildNumber = assembly.FullName.ToUpper(CultureInfo.InvariantCulture);
					int	versionIndex = buildNumber.IndexOf("VERSION=", StringComparison.Ordinal);
					if(versionIndex >= 0)
					{
						buildNumber = buildNumber.Substring(versionIndex + 8);
					}
                    versionIndex = buildNumber.IndexOf(",", StringComparison.Ordinal);
					if(versionIndex >= 0)
					{
						buildNumber = buildNumber.Substring(0, versionIndex);
					}
				}
				return buildNumber;
			}
		}

		/// <summary>
		/// Chart serializer object.
		/// </summary>
		[
		SRCategory("CategoryAttributeSerializer"),
		SRDescription("DescriptionAttributeChart_Serializer"),
		Browsable(false),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden)
		]
		public ChartSerializer Serializer
		{
			get
			{
				return _chartSerializer;
			}
		}



		/// <summary>
		/// Image type (Jpeg, BMP, Png, Svg, Flash)
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(ChartImageType.Png),
		SRDescription("DescriptionAttributeChartImageType"),
        PersistenceMode(PersistenceMode.Attribute),
		RefreshProperties(RefreshProperties.All)
		]
		public ChartImageType ImageType
		{
			get
			{
				return chartPicture.ImageType;
			}
			set
			{
				chartPicture.ImageType = value;
			}
		}

		/// <summary>
		/// Image compression value
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(0),
		SRDescription("DescriptionAttributeChart_Compression"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public int Compression
		{
			get
			{
				return chartPicture.Compression;
			}
			set
			{
				chartPicture.Compression = value;
			}
		}

        /*
         * Disabled until we get responce from Microsoft
         *  --- Alex
         * 
                /// <summary>
                /// Gif image transparent color
                /// </summary>
                [
                SRCategory("CategoryAttributeImage"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
                Description("Gif image transparent color."),
                PersistenceMode(PersistenceMode.Attribute),
                TypeConverter(typeof(ColorConverter)),
                Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color TransparentColor
                {
                    get
                    {
                        return chartPicture.TransparentColor;
                    }
                    set
                    {
                        chartPicture.TransparentColor = value;
                    }
                }
        */
        #endregion

        #region Chart Image Properties

        /// <summary>
        /// Indicates that chart image map is enabled.
        /// </summary>
        [
        SRCategory("CategoryAttributeMap"),
        Bindable(true),
        SRDescription(SR.Keys.DescriptionAttributeIsMapAreaAttributesEncoded),
        PersistenceModeAttribute(PersistenceMode.Attribute),
        DefaultValue(false)
        ]
        public bool IsMapAreaAttributesEncoded { get; set; }


        /// <summary>
		/// Indicates that chart image map is enabled.
		/// </summary>
		[
		SRCategory("CategoryAttributeMap"),
		Bindable(true),
		SRDescription("DescriptionAttributeMapEnabled"),
		PersistenceModeAttribute(PersistenceMode.Attribute),
		DefaultValue(true)
		]
		public bool IsMapEnabled
		{
			get
			{
				return chartPicture.IsMapEnabled;
			}
			set
			{
				chartPicture.IsMapEnabled = value;
			}
		}

		/// <summary>
		/// Chart map areas collection.
		/// </summary>
		[
        SRCategory("CategoryAttributeMap"),
		SRDescription("DescriptionAttributeMapAreas"),
		PersistenceModeAttribute(PersistenceMode.InnerProperty),
        Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
		]
		public MapAreasCollection MapAreas
		{
			get
			{
				return chartPicture.MapAreas;
			}
		}

		/// <summary>
		/// Specifies whether smoothing (antialiasing) is applied while drawing chart.
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
        DefaultValue(typeof(AntiAliasingStyles), "All"),
		SRDescription("DescriptionAttributeAntiAlias"),
		PersistenceMode(PersistenceMode.Attribute),
		Editor(Editors.FlagsEnumUITypeEditor.Editor, Editors.FlagsEnumUITypeEditor.Base)
		]
        public AntiAliasingStyles AntiAliasing
		{
			get
			{
				return chartPicture.AntiAliasing;
			}
			set
			{
				chartPicture.AntiAliasing = value;
			}
		}

		/// <summary>
		/// Specifies the quality of text antialiasing.
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(typeof(TextAntiAliasingQuality), "High"),
		SRDescription("DescriptionAttributeTextAntiAliasingQuality"),
#if !Microsoft_CONTROL
		PersistenceMode(PersistenceMode.Attribute)
#endif
		]
		public TextAntiAliasingQuality TextAntiAliasingQuality
		{
			get
			{
				return chartPicture.TextAntiAliasingQuality;
			}
			set
			{
				chartPicture.TextAntiAliasingQuality = value;
			}
		}

		/// <summary>
		/// Specifies whether smoothing is applied while drawing shadows.
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(true),
		SRDescription("DescriptionAttributeChart_SoftShadows"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public bool IsSoftShadows
		{
			get
			{
				return chartPicture.IsSoftShadows;
			}
			set
			{
				chartPicture.IsSoftShadows = value;
			}
		}

		/// <summary>
		/// Reference to chart area collection
		/// </summary>
		[
		SRCategory("CategoryAttributeChart"),
		Bindable(true),
		SRDescription("DescriptionAttributeChartAreas"),
		PersistenceMode(PersistenceMode.InnerProperty),
		Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
		]
		public ChartAreaCollection ChartAreas
		{
			get
			{
				return chartPicture.ChartAreas;
			}
		}

		/// <summary>
		/// Back ground color for the Chart
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(typeof(Color), "White"),
        SRDescription("DescriptionAttributeBackColor"),
		PersistenceMode(PersistenceMode.Attribute),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
		]
		public override Color BackColor
		{
			get
			{
				return chartPicture.BackColor;
			}
			set
			{
				chartPicture.BackColor = value;
			}
		}

		/// <summary>
		/// Fore color propery (not used)
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(false),
		Browsable(false),
		DefaultValue(typeof(Color), ""),
		SRDescription("DescriptionAttributeChart_ForeColor"),
		PersistenceMode(PersistenceMode.Attribute),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
		]
		public override Color ForeColor
		{
			get
			{
				return Color.Empty;
			}
			set
			{
			}
		}

		/// <summary>
		/// Chart width
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(typeof(Unit), "300"),
		SRDescription("DescriptionAttributeWidth"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public override Unit Width
		{
			get
			{
				return new Unit(chartPicture.Width);
			}
			set
			{
				if(value.Type != UnitType.Pixel)
				{
                    throw (new ArgumentException(SR.ExceptionChartWidthIsNotInPixels));
				}
				chartPicture.Width = (int)value.Value;
			}
		}

		/// <summary>
		/// Chart legend collection.
		/// </summary>
		[
		SRCategory("CategoryAttributeChart"),
		SRDescription("DescriptionAttributeLegends"),
		PersistenceMode(PersistenceMode.InnerProperty),
		Editor(Editors.LegendCollectionEditor.Editor, Editors.LegendCollectionEditor.Base),
		]
		public LegendCollection Legends
		{
			get
			{
				return chartPicture.Legends;
			}
		}

		/// <summary>
		/// Chart title collection.
		/// </summary>
		[
		SRCategory("CategoryAttributeChart"),
		SRDescription("DescriptionAttributeTitles"),
        Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base),
		PersistenceMode(PersistenceMode.InnerProperty),
		]
		public TitleCollection Titles
		{
			get
			{
				return chartPicture.Titles;
			}
		}


		/// <summary>
		/// Chart annotation collection.
		/// </summary>
		[
		SRCategory("CategoryAttributeChart"),
		SRDescription("DescriptionAttributeAnnotations3"),
		Editor(Editors.AnnotationCollectionEditor.Editor, Editors.AnnotationCollectionEditor.Base),
		PersistenceMode(PersistenceMode.InnerProperty),
		]
		public AnnotationCollection Annotations
		{
			get
			{
				return chartPicture.Annotations;
			}
		}


		/// <summary>
		/// Series data manipulator
		/// </summary>
		[
		SRCategory("CategoryAttributeData"),
		SRDescription("DescriptionAttributeDataManipulator"),
		Browsable(false),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden)
		]
		public DataManipulator DataManipulator
		{
			get
			{
				return chartPicture.DataManipulator;
			}
		}


		/// <summary>
		/// Chart height
		/// </summary>
		[
		SRCategory("CategoryAttributeImage"),
		Bindable(true),
		DefaultValue(typeof(Unit), "300"),
		SRDescription("DescriptionAttributeHeight3"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public override Unit Height
		{
			get
			{
				return new Unit(chartPicture.Height);
			}
			set
			{
				if(value.Type != UnitType.Pixel)
				{
                    throw (new ArgumentException(SR.ExceptionChartHeightIsNotInPixels));
				}
				chartPicture.Height = (int)value.Value;
			}
		}


		/// <summary>
		/// Back Hatch style
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(ChartHatchStyle.None),
        SRDescription("DescriptionAttributeBackHatchStyle"),
		PersistenceMode(PersistenceMode.Attribute),
		Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
		]
		public ChartHatchStyle BackHatchStyle
		{
			get
			{
				return chartPicture.BackHatchStyle;
			}
			set
			{
				chartPicture.BackHatchStyle = value;
			}
		}

		/// <summary>
		/// Chart area background image
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(""),
        SRDescription("DescriptionAttributeBackImage"),
		PersistenceMode(PersistenceMode.Attribute),
		NotifyParentPropertyAttribute(true),
        Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base)
		]
		public string BackImage
		{
			get
			{
				return chartPicture.BackImage;
			}
			set
			{
				chartPicture.BackImage = value;
			}
		}

		/// <summary>
		/// Chart area background image drawing mode.
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(ChartImageWrapMode.Tile),
		NotifyParentPropertyAttribute(true),
        SRDescription("DescriptionAttributeImageWrapMode"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public ChartImageWrapMode BackImageWrapMode
		{
			get
			{
				return chartPicture.BackImageWrapMode;
			}
			set
			{
				chartPicture.BackImageWrapMode = value;
			}
		}

		/// <summary>
		/// Background image transparent color.
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(typeof(Color), ""),
		NotifyParentPropertyAttribute(true),
        SRDescription("DescriptionAttributeImageTransparentColor"),
		PersistenceMode(PersistenceMode.Attribute),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
		]
		public Color BackImageTransparentColor
		{
			get
			{
				return chartPicture.BackImageTransparentColor;
			}
			set
			{
				chartPicture.BackImageTransparentColor = value;
			}
		}

		/// <summary>
		/// Background image alignment used by ClampUnscale drawing mode.
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(ChartImageAlignmentStyle.TopLeft),
		NotifyParentPropertyAttribute(true),
        SRDescription("DescriptionAttributeBackImageAlign"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public ChartImageAlignmentStyle BackImageAlignment
		{
			get
			{
				return chartPicture.BackImageAlignment;
			}
			set
			{
				chartPicture.BackImageAlignment = value;
			}
		}

		/// <summary>
		/// A type for the background gradient
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(GradientStyle.None),
        SRDescription("DescriptionAttributeBackGradientStyle"),
		PersistenceMode(PersistenceMode.Attribute),
		Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
		]
		public GradientStyle BackGradientStyle
		{
			get
			{
				return chartPicture.BackGradientStyle;
			}
			set
			{
				chartPicture.BackGradientStyle = value;
			}
		}

		/// <summary>
		/// The second color which is used for a gradient
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeBackSecondaryColor"),
		PersistenceMode(PersistenceMode.Attribute),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
		]
		public Color BackSecondaryColor
		{
			get
			{
				return chartPicture.BackSecondaryColor;
			}
			set
			{
				chartPicture.BackSecondaryColor = value;
			}
		}

        
        /// <summary>
        /// Gets or sets the border color of the Chart.
        /// </summary>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public override Color BorderColor
        {
            get { return base.BorderColor; }
            set { base.BorderColor = value; }
        }
        
        /// <summary>
        /// Gets or sets the border width of the Chart.
        /// </summary>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public override Unit  BorderWidth
        {
          get { return base.BorderWidth;}
          set { base.BorderWidth = value;}
        }
        
        /// <summary>
        /// Gets or sets the border style of the Chart.
        /// </summary>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public override BorderStyle BorderStyle
        {
            get { return base.BorderStyle; }
            set { base.BorderStyle = value; }
        }


		/// <summary>
		/// Border line color for the Chart
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(typeof(Color), "White"),
		SRDescription("DescriptionAttributeBorderColor"),
		PersistenceMode(PersistenceMode.Attribute),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
		]
		public Color BorderlineColor
		{
			get
			{
				return chartPicture.BorderColor;
			}
			set
			{
				chartPicture.BorderColor = value;
			}
		}

		/// <summary>
		/// The width of the border line
		/// </summary>
		[
        SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(1),
		SRDescription("DescriptionAttributeChart_BorderlineWidth"),
		PersistenceMode(PersistenceMode.Attribute)
		]
		public int BorderlineWidth
		{
			get
			{
				return chartPicture.BorderWidth;
			}
			set
			{
				chartPicture.BorderWidth = value;
			}
		}

		/// <summary>
		/// The style of the border line
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(ChartDashStyle.NotSet),
		SRDescription("DescriptionAttributeBorderDashStyle"),
		PersistenceMode(PersistenceMode.Attribute) 
		]
		public ChartDashStyle BorderlineDashStyle
		{
			get
			{
				return chartPicture.BorderDashStyle;
			}
			set
			{
				chartPicture.BorderDashStyle = value;
			}
		}

        /// <summary>
		/// Chart border skin style.
		/// </summary>
		[
		SRCategory("CategoryAttributeAppearance"),
		Bindable(true),
		DefaultValue(BorderSkinStyle.None),
		SRDescription("DescriptionAttributeBorderSkin"),
		PersistenceMode(PersistenceMode.InnerProperty),
		NotifyParentProperty(true),
		TypeConverterAttribute(typeof(LegendConverter)),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content) 
		]
		public BorderSkin BorderSkin
		{
			get
			{
				return chartPicture.BorderSkin;
			}
			set
			{
				chartPicture.BorderSkin = value;
			}
		}

        /// <summary>
        /// When overridden in a derived class, gets or sets the alternate text displayed in the Chart control when the chart image is unavailable.
        /// </summary>
        [
        Bindable(true),
        SRDescription(SR.Keys.DescriptionAttributeChartImageAlternateText), 
        Localizable(true), 
        SRCategory(SR.Keys.CategoryAttributeAppearance), 
        DefaultValue("")
        ]
        public string AlternateText { get; set; }

        /// <summary>
        /// When overridden in a derived class, gets or sets the location to a detailed description for the chart.
        /// </summary>
        [
        Bindable(true),
        SRDescription(SR.Keys.DescriptionAttributeChartImageDescriptionUrl), 
        Localizable(true), 
        SRCategory(SR.Keys.CategoryAttributeAccessibility), 
        DefaultValue(""), 
        UrlProperty,
        Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base),
        SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings")
        ]
        public string DescriptionUrl { get; set; }

		#endregion

		#region Control public methods

        /// <summary>
        /// Creates the HTML text writer.
        /// </summary>
        /// <param name="tw">The inner text writer.</param>
        /// <returns></returns>
        private HtmlTextWriter CreateHtmlTextWriter(TextWriter tw)
        {
            if (((this.Context != null) && (this.Context.Request != null)) && (this.Context.Request.Browser != null))
            {
                return this.Context.Request.Browser.CreateHtmlTextWriter(tw);
            }
            return new Html32TextWriter(tw);
        }

		/// <summary>
		/// Gets HTML image map of the currently rendered chart.
		/// Save(...) method MUST be called before calling this method!
		/// </summary>
		/// <param name="name">Name of the image map tag.</param>
		/// <returns>HTML image map.</returns>
		public string GetHtmlImageMap(string name)
		{
            // Check arguments
            if (name == null)
                throw new ArgumentNullException("name");

            using (StringWriter swriter = new StringWriter(CultureInfo.InvariantCulture))
            {
                using (HtmlTextWriter writer = CreateHtmlTextWriter(swriter))
                {
                    this.chartPicture.WriteChartMapTag(writer, name);
                    return swriter.GetStringBuilder().ToString();
                }
            }
		}


		/// <summary>
		/// Saves the current state of the chart to an XML file.  This is
		/// mainly used for support purposes.  The executing thread must have
		/// file write permission
		/// </summary>
		/// <param name="name">File path and name to save.</param>
		public void SaveXml(string name)
		{
			try
			{
				this.Serializer.Save(name);
			}
			catch(XmlException)
			{ }
		}


		/// <summary>
		/// Loads chart appearance template from file.
		/// </summary>
		/// <param name="name">Template file name to load from.</param>
		public void LoadTemplate(string name)
		{
			chartPicture.LoadTemplate(name);
		}

		/// <summary>
		/// Loads chart appearance template from stream.
		/// </summary>
		/// <param name="stream">Template stream to load from.</param>
		public void LoadTemplate(Stream stream)
		{
			chartPicture.LoadTemplate(stream);
		}


		/// <summary>
		/// Applies palette colors to series or data points.
		/// </summary>
		public void ApplyPaletteColors()
		{
			// Apply palette colors to series
			this._dataManager.ApplyPaletteColors();

			// Apply palette colors to data Points in series
			foreach(Series series in this.Series)
			{
				// Check if palette colors should be aplied to the points
				bool	applyToPoints = false;
				if(series.Palette != ChartColorPalette.None)
				{
					applyToPoints = true;
				}
				else
				{
					IChartType chartType = this._chartTypeRegistry.GetChartType(series.ChartTypeName);
					applyToPoints = chartType.ApplyPaletteColorsToPoints;
				}

				// Apply palette colors to the points
				if(applyToPoints)
				{
					series.ApplyPaletteColors();
				}
			}
		}

		/// <summary>
		/// Checks if control is in design mode.
		/// </summary>
		/// <returns>True if control is in design mode.</returns>
		internal bool IsDesignMode()
		{
            return this.DesignMode;
        }

		/// <summary>
		/// Reset auto calculated chart properties values to "Auto".
		/// </summary>
		public void ResetAutoValues()
		{
			// Reset auto calculated series properties values 
			foreach(Series series in this.Series)
			{
				series.ResetAutoValues();
			}

			// Reset auto calculated axis properties values 
			foreach(ChartArea chartArea in this.ChartAreas)
			{
				chartArea.ResetAutoValues();
			}

		}

		#endregion

		#region Control DataBind method

        /// <summary>
        /// Verifies that the object a data-bound control binds to is one it can work with.
        /// </summary>
        /// <param name="dataSource">The object to verify</param>
        protected override void ValidateDataSource(object dataSource)
        {
            if (!ChartImage.IsValidDataSource(dataSource))
            {
                base.ValidateDataSource(dataSource);
            }
        } 

        /// <summary>
        /// Binds the specified data source to the Chart control.
        /// </summary>
        /// <param name="data">An <see cref="IEnumerable"/> that represents the data source.</param>
        protected override void PerformDataBinding(IEnumerable data)
        {
            this.chartPicture.DataBind(data, null);
            this.chartPicture.boundToDataSource = true;
        }

		/// <summary>
		/// Aligns data points using their axis labels.
		/// </summary>
		public void AlignDataPointsByAxisLabel()
		{
			this.chartPicture.AlignDataPointsByAxisLabel(false, PointSortOrder.Ascending);
		}

		/// <summary>
		/// Aligns data points using their axis labels.
		/// </summary>
		/// <param name="series">Comma separated list of series that should be aligned by axis label.</param>
		public void AlignDataPointsByAxisLabel(string series)
		{
			// Create list of series
			ArrayList seriesList = new ArrayList();
			string[] seriesNames = series.Split(',');
			foreach(string name in seriesNames)
			{
				seriesList.Add(this.Series[name.Trim()]);
			}

			// Align series
			this.chartPicture.AlignDataPointsByAxisLabel(seriesList, false, PointSortOrder.Ascending);
		}

		/// <summary>
		/// Aligns data points using their axis labels.
		/// </summary>
		/// <param name="series">Comma separated list of series that should be aligned by axis label.</param>
		/// <param name="sortingOrder">Points sorting order by axis labels.</param>
		public void AlignDataPointsByAxisLabel(string series, PointSortOrder sortingOrder)
		{
			// Create list of series
			ArrayList seriesList = new ArrayList();
			string[] seriesNames = series.Split(',');
			foreach(string name in seriesNames)
			{
				seriesList.Add(this.Series[name.Trim()]);
			}

			// Align series
			this.chartPicture.AlignDataPointsByAxisLabel(seriesList, true, sortingOrder);
		}

		/// <summary>
		/// Aligns data points using their axis labels.
		/// </summary>
		/// <param name="sortingOrder">Points sorting order by axis labels.</param>
		public void AlignDataPointsByAxisLabel(PointSortOrder sortingOrder)
		{
			this.chartPicture.AlignDataPointsByAxisLabel(true, sortingOrder);
		}



		/// <summary>
		/// Automatically creates and binds series to specified data table. 
		/// Each column of the table becomes a Y value in a separate series.
		/// Series X value field may also be provided. 
		/// </summary>
		/// <param name="dataSource">Data source.</param>
		/// <param name="xField">Name of the field for series X values.</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X is a cartesian coordinate and well understood")]
        public void DataBindTable(
			IEnumerable dataSource, 
			string xField)
		{
			this.chartPicture.DataBindTable(
				dataSource, 
				xField);
		}

		/// <summary>
		/// Automatically creates and binds series to specified data table. 
		/// Each column of the table becomes a Y value in a separate series.
		/// </summary>
		/// <param name="dataSource">Data source.</param>
		public void DataBindTable(IEnumerable dataSource)
		{
			this.chartPicture.DataBindTable(
				dataSource, 
				String.Empty);
		}

		/// <summary>
		/// Data bind chart to the table. Series will be automatically added to the chart depending on 
		/// the number of unique values in the seriesGroupByField column of the data source.
		/// Data source can be the Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
		/// </summary>
		/// <param name="dataSource">Data source.</param>
		/// <param name="seriesGroupByField">Name of the field used to group data into series.</param>
		/// <param name="xField">Name of the field for X values.</param>
		/// <param name="yFields">Comma separated name(s) of the field(s) for Y value(s).</param>
		/// <param name="otherFields">Other point properties binding rule in format: PointProperty=Field[{Format}] [,PointProperty=Field[{Format}]]. For example: "Tooltip=Price{C1},Url=WebSiteName".</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public void DataBindCrossTable(
			IEnumerable dataSource, 
			string seriesGroupByField, 
			string xField, 
			string yFields, 
			string otherFields)
		{
			this.chartPicture.DataBindCrossTab(
				dataSource, 
				seriesGroupByField, 
				xField, 
				yFields, 
				otherFields,
				false,
				PointSortOrder.Ascending);
		}

		/// <summary>
		/// Data bind chart to the table. Series will be automatically added to the chart depending on
		/// the number of unique values in the seriesGroupByField column of the data source.
		/// Data source can be the Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
		/// </summary>
		/// <param name="dataSource">Data source.</param>
		/// <param name="seriesGroupByField">Name of the field used to group data into series.</param>
		/// <param name="xField">Name of the field for X values.</param>
		/// <param name="yFields">Comma separated name(s) of the field(s) for Y value(s).</param>
		/// <param name="otherFields">Other point properties binding rule in format: PointProperty=Field[{Format}] [,PointProperty=Field[{Format}]]. For example: "Tooltip=Price{C1},Url=WebSiteName".</param>
		/// <param name="sortingOrder">Series will be sorted by group field values in specified order.</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
            Justification = "X and Y are cartesian coordinates and well understood")]
        public void DataBindCrossTable(
			IEnumerable dataSource, 
			string seriesGroupByField, 
			string xField, 
			string yFields, 
			string otherFields,
			PointSortOrder sortingOrder)
		{
			this.chartPicture.DataBindCrossTab(
				dataSource, 
				seriesGroupByField, 
				xField, 
				yFields, 
				otherFields,
				true,
				sortingOrder);
		}


		#endregion

		#region Special Extension Methods and Properties

		/// <summary>
		/// Gets the requested chart service.
		/// </summary>
		/// <param name="serviceType">Type of requested chart service.</param>
		/// <returns>Instance of the service or null if it can't be found.</returns>
		public object GetService(Type serviceType)
		{
            // Check arguments
            if (serviceType == null)
                throw new ArgumentNullException("serviceType");

			object service = null;
			if(serviceContainer != null)
			{
				service = serviceContainer.GetService(serviceType);
			}

			return service;
		}

        /// <summary>
        /// Called when a numeric value has to be converted to a string.
        /// </summary>
        [SRDescription("DescriptionAttributeChartEvent_PrePaint")]
        public event EventHandler<FormatNumberEventArgs> FormatNumber;

        /// <summary>
        /// Called when a numeric value has to be converted to a string.
        /// </summary>
        /// <param name="caller">Event caller. Can be ChartPicture, ChartArea or Legend objects.</param>
        /// <param name="e">Event arguments.</param>
        [SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "1#")]
        protected virtual void OnFormatNumber(object caller, FormatNumberEventArgs e)
        {
            if (FormatNumber != null)
            {
                FormatNumber(caller, e);
            }
        }

        /// <summary>
        /// Called when a numeric value has to be converted to a string.
        /// </summary>
        /// <param name="caller">Event caller. Can be ChartPicture, ChartArea or Legend objects.</param>
        /// <param name="e">Event arguments.</param>
        internal void CallOnFormatNumber(object caller, FormatNumberEventArgs e)
        {
            this.OnFormatNumber(caller, e);
        }

		#endregion

        #region HttpHandler Support

        /// <summary>
        /// Chart rendering type. Image tag, input tag, binary data streaming and image map are the options.
        /// </summary>
        [
        SRCategory("CategoryAttributeImage"),
        Bindable(true),
        SRDescription("DescriptionAttributeChart_ImageStorageMode"),
        PersistenceModeAttribute(PersistenceMode.Attribute),
        DefaultValue(ImageStorageMode.UseHttpHandler)
        ]
        public ImageStorageMode ImageStorageMode
        {
            get
            {
                return this._imageStorageMode;
            }
            set
            {
                this._imageStorageMode = value;
            }
        }
        
        /// <summary>
        /// Gets the image storage mode.
        /// </summary>
        /// <returns></returns>
        internal ImageStorageMode GetImageStorageMode()
        {
            if (this.ImageStorageMode == ImageStorageMode.UseHttpHandler)
            {
                ChartHttpHandler.EnsureInstalled();
            }
            return this.ImageStorageMode;
        }

        #endregion //HttpHandler Support

        #region IPostBackEventHandler Members

        void IPostBackEventHandler.RaisePostBackEvent(string eventArgument)
        {
            this.RaisePostBackEvent(eventArgument);
        }

        #endregion

        #region IDisposable overrides
        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (!String.IsNullOrEmpty(_designTimeChart))
                {
                    try
                    {
                        File.Delete(_designTimeChart);
                    }
                    catch (ArgumentException) { }
                    catch (DirectoryNotFoundException) { }
                    catch (IOException) { }
                    catch (NotSupportedException) { }
                    catch (UnauthorizedAccessException) { }
                }

                // Dispose managed objects here
                if (_imageLoader != null)
                {
                    _imageLoader.Dispose();
                    _imageLoader = null;
                }
                if (_namedImages != null)
                {
                    _namedImages.Dispose();
                    _namedImages = null;
                }
                if (_chartTypeRegistry != null)
                {
                    _chartTypeRegistry.Dispose();
                    _chartTypeRegistry = null;
                }
                if (serviceContainer != null)
                {
                    serviceContainer.Dispose();
                    serviceContainer = null;
                }
                if (_license != null)
                {
                    _license.Dispose();
                    _license = null;
                }
            }
            //Base dispose
            base.Dispose();
            if (disposing)
            {
                if (_dataManager != null)
                {
                    _dataManager.Dispose();
                    _dataManager = null;
                }
                if (chartPicture != null)
                {
                    chartPicture.Dispose();
                    chartPicture = null;
                }
            }
        }

        /// <summary>
        /// Disposing control resoursec
        /// </summary>
        public override sealed void Dispose()
        {
            Dispose(true);                        
            GC.SuppressFinalize(this);
        }

        #endregion

    }

	/// <summary>
	/// Chart map areas customize events arguments
	/// </summary>
#if ASPPERM_35
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class CustomizeMapAreasEventArgs : EventArgs
	{
		private	MapAreasCollection	_areaItems = null;

		/// <summary>
		/// Default construvtor is not accessible
		/// </summary>
		private CustomizeMapAreasEventArgs()
		{
		}

		/// <summary>
		/// Customize map area event arguments constructor
		/// </summary>
		/// <param name="areaItems">Legend items collection.</param>
		public CustomizeMapAreasEventArgs(MapAreasCollection areaItems)
		{
			this._areaItems = areaItems;
		}

		/// <summary>
		/// Legend items collection.
		/// </summary>
		public MapAreasCollection MapAreaItems
		{
			get
			{
				return _areaItems;
			}
		} 

	}



	/// <summary>
	/// Chart legend customize events arguments
	/// </summary>
#if ASPPERM_35
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif 
    public class CustomizeLegendEventArgs : EventArgs
	{
		private	LegendItemsCollection	_legendItems = null;
		private	string					_legendName = "";

		/// <summary>
		/// Default construvtor is not accessible
		/// </summary>
		private CustomizeLegendEventArgs()
		{
		}

		/// <summary>
		/// Customize legend event arguments constructor
		/// </summary>
		/// <param name="legendItems">Legend items collection.</param>
		public CustomizeLegendEventArgs(LegendItemsCollection legendItems)
		{
			this._legendItems = legendItems;
		}

		/// <summary>
		/// Customize legend event arguments constructor
		/// </summary>
		/// <param name="legendItems">Legend items collection.</param>
		/// <param name="legendName">Legend name.</param>
		public CustomizeLegendEventArgs(LegendItemsCollection legendItems, string legendName)
		{
			this._legendItems = legendItems;
			this._legendName = legendName;
		}

		/// <summary>
		/// Legend name.
		/// </summary>
		public string LegendName
		{
			get
			{
				return _legendName;
			}
		} 

		/// <summary>
		/// Legend items collection.
		/// </summary>
		public LegendItemsCollection LegendItems
		{
			get
			{
				return _legendItems;
			}
		} 

	}

    /// <summary>
    /// Specifies a value indicating whether the text appears from right to left, such as when using Hebrew or Arabic fonts
    /// </summary>
    public enum RightToLeft
    {
        /// <summary>
        /// The text reads from left to right. This is the default.
        /// </summary>
        No,
        /// <summary>
        /// The text reads from right to left.
        /// </summary>
        Yes,
        /// <summary>
        /// Not used
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        Inherit = No
    }
}