Updates referencesource to .NET 4.7

[mono.git] / mcs / class / referencesource / System.Web.DataVisualization / Common / General / Chart.cs

//-------------------------------------------------------------
// <copyright company=\92Microsoft Corporation\92>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:               Chart.cs
//
//  Namespace:  System.Web.UI.WebControls[Windows.Forms].Charting
//
//      Classes:        ChartImage, ChartPicture, ChartPaintEventArgs
//
//  Purpose:    This file contains classes, which are used for Image 
//                              creation and chart painting. This file has also a 
//                              class, which is used for Paint events arguments.
//
//      Reviewed:       GS - August 2, 2002
//                              AG - August 8, 2002
//              AG - Microsoft 16, 2007
//
//===================================================================

#region Used Namespaces

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Design;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Resources;
using System.Reflection;
using System.IO;
using System.Data;
using System.Collections;
using System.Drawing.Imaging;
using System.Drawing.Text;
using System.Xml;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics;
using System.Security;
using System.Runtime.InteropServices;
using System.Collections.Generic;

#if Microsoft_CONTROL

        using System.Windows.Forms.DataVisualization.Charting.Data;
        using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
        using System.Windows.Forms.DataVisualization.Charting.Utilities;
        using System.Windows.Forms.DataVisualization.Charting.Borders3D;
        using System.Windows.Forms.DataVisualization.Charting;
#else
        using System.Web;
        using System.Web.UI;
        using System.Net;
        using System.Web.UI.DataVisualization.Charting;
        using System.Web.UI.DataVisualization.Charting.Data;
        using System.Web.UI.DataVisualization.Charting.ChartTypes;
        using System.Web.UI.DataVisualization.Charting.Utilities;
        using System.Web.UI.DataVisualization.Charting.Borders3D;
#endif


#endregion

#if Microsoft_CONTROL
namespace System.Windows.Forms.DataVisualization.Charting
#else
namespace System.Web.UI.DataVisualization.Charting

#endif
{
        #region Enumerations

#if !Microsoft_CONTROL

        /// <summary>
        /// An enumeration of supported image types
        /// </summary>
        public enum ChartImageType
        {
                /// <summary>
                /// BMP image format
                /// </summary>
                Bmp,
                /// <summary>
                /// Jpeg image format
                /// </summary>
                Jpeg, 

                /// <summary>
                /// Png image format
                /// </summary>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Png")]
        Png,
                
                /// <summary>
                /// Enhanced Meta File (Emf) image format.
                /// </summary>
                Emf,

    };
#endif


        #endregion

        /// <summary>
    /// ChartImage class adds image type and data binding functionality to 
    /// the base ChartPicture class.
        /// </summary>
        internal class ChartImage : ChartPicture
        {
                #region Fields

                // Private data members, which store properties values
                private int                             _compression = 0;

                // Chart data source object
                private object  _dataSource = null;

                // Indicates that control was bound to the data source
                internal bool   boundToDataSource = false;

#if !Microsoft_CONTROL
                private ChartImageType  imageType = ChartImageType.Png;
#endif
                
                #endregion

                #region Constructor

                /// <summary>
                /// Chart internal constructor.
                /// </summary>
                /// <param name="container">Service container</param>
        internal ChartImage(IServiceContainer container)
            : base(container)
        {
        }

                #endregion // Constructor
        
                #region Properties

                /// <summary>
        /// Gets or sets the data source for the Chart object.
                /// </summary>
                [
                SRCategory("CategoryAttributeData"),
                Bindable(true),
                SRDescription("DescriptionAttributeDataSource"),
                DefaultValue(null),
                DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
                SerializationVisibilityAttribute(SerializationVisibility.Hidden)
                ]
                public object DataSource
                {
                        get
                        {
                                return _dataSource;
                        }
                        set
                        {
                                if(_dataSource != value)
                                {
                                        _dataSource = value;
                                        this.boundToDataSource = false;
                                }
                        }
                }

#if !Microsoft_CONTROL

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

#endif

                /// <summary>
                /// Image compression value
                /// </summary>
                [
                SRCategory("CategoryAttributeImage"),
                Bindable(true),
                DefaultValue(0),
                SRDescription("DescriptionAttributeChartImage_Compression"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public int Compression
                {
                        get
                        {
                                return _compression;
                        }
                        set
                        {
                                if(value < 0 || value > 100)
                                {
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionChartCompressionInvalid));
                                }
                                _compression = value;
                        }
                }

                #endregion

                #region Methods

                #region Image Manipulation


                /// <summary>
                /// Saves image into the metafile stream. 
                /// </summary>
                /// <param name="imageStream">Image stream.</param>
                /// <param name="emfType">Image stream.</param>
        [SecuritySafeCritical]
                public void SaveIntoMetafile(Stream imageStream, EmfType emfType)
                {
            // Check arguments
            if (imageStream == null)
                throw new ArgumentNullException("imageStream");

                        // Create temporary Graphics object for metafile
            using (Bitmap bitmap = new Bitmap(this.Width, this.Height))
            {
                using (Graphics newGraphics = Graphics.FromImage(bitmap))
                {
                    IntPtr hdc = IntPtr.Zero;
                    try
                    {
                        System.Security.Permissions.SecurityPermission securityPermission = new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode);
                        securityPermission.Demand();
                        
                        hdc = newGraphics.GetHdc();


                        // Create metafile object to record.
                        using (Metafile metaFile = new Metafile(
                            imageStream,
                            hdc,
                            new Rectangle(0, 0, this.Width, this.Height),
                            MetafileFrameUnit.Pixel,
                            emfType))
                        {

                            // Create graphics object to record metaFile.
                            using (Graphics metaGraphics = Graphics.FromImage(metaFile))
                            {

                                // Note: Fix for issue #3674. Some 3D borders shadows may be drawn outside 
                                // of image boundaries. This causes issues when generated EMF file 
                                // is placed in IE. Image looks shifted down and hot areas do not align.
                                if (this.BorderSkin.SkinStyle != BorderSkinStyle.None)
                                {
                                    metaGraphics.Clip = new Region(new Rectangle(0, 0, this.Width, this.Height));
                                }

                                // Draw chart in the metafile
                                this.ChartGraph.IsMetafile = true;
                                this.Paint(metaGraphics, false);
                                this.ChartGraph.IsMetafile = false;

                            }
                        }
                    }
                    finally
                    {
                        if (hdc != IntPtr.Zero)
                        {
                            newGraphics.ReleaseHdc(hdc);
                        }
                    }
                }
            }
                }
        
        public Bitmap GetImage()
        {
            return this.GetImage(96);
        }
                /// <summary>
                /// Create Image and draw chart picture
                /// </summary>
        public Bitmap GetImage(float resolution)
                {
                        // Create a new bitmap

            Bitmap image = null;

            while (image == null)
            {
                bool failed = true;
                try
                {
                    image = new Bitmap(Math.Max(1,Width), Math.Max(1,Height));
                    image.SetResolution(resolution, resolution);
                    failed = false;
                }
                catch (ArgumentException)
                {
                    failed = true;
                }
                catch (OverflowException)
                {
                    failed = true;
                }
                catch (InvalidOperationException)
                {
                    failed = true;
                }
                catch (ExternalException)
                {
                    failed = true;
                }

                if (failed)
                {
                    // if failed to create the image, decrease the size and the resolution of the chart
                    image = null;
                    float newResolution = Math.Max(resolution / 2, 96);
                    Width = (int)Math.Ceiling(Width * newResolution / resolution);
                    Height = (int)Math.Ceiling(Height * newResolution / resolution);
                    resolution = newResolution;
                }
            }

                        // Creates a new Graphics object from the 
                        // specified Image object.
                        Graphics offScreen = Graphics.FromImage( image );



            Color backGroundColor;

            if (this.BackColor != Color.Empty)
                backGroundColor = this.BackColor;
            else
                backGroundColor = Color.White;

            // Get the page color if border skin is visible.
            if (GetBorderSkinVisibility() &&
                this.BorderSkin.PageColor != Color.Empty)
            {
                backGroundColor = this.BorderSkin.PageColor;
            }

            // draw a rctangle first with the size of the control, this prevent strange behavior when printing in the reporting services,
            // without this rectangle, the printed picture is blurry
            Pen pen = new Pen(backGroundColor);
            offScreen.DrawRectangle(pen, 0, 0, Width, Height);
            pen.Dispose();

                        // Paint the chart
                        Paint( offScreen , false);

                        // Dispose Graphic object
                        offScreen.Dispose();

                        // Return reference to the image
                        return image;
                }

                #endregion // Image Manipulation

                #region Data Binding

                /// <summary>
                /// Checks if the type of the data source is valid.
                /// </summary>
                /// <param name="dataSource">Data source object to test.</param>
                /// <returns>True if valid data source object.</returns>
                static internal bool IsValidDataSource(object dataSource)
                {
            if( null != dataSource && 
                (
                dataSource is IEnumerable ||
                                dataSource is DataSet ||
                                dataSource is DataView ||
                                dataSource is DataTable ||
                                dataSource is System.Data.OleDb.OleDbCommand ||
                                dataSource is System.Data.SqlClient.SqlCommand ||
                                dataSource is System.Data.OleDb.OleDbDataAdapter ||
                                dataSource is System.Data.SqlClient.SqlDataAdapter ||
                                // ADDED: for VS2005 compatibility, DT Nov 25, 2005
                                dataSource.GetType().GetInterface("IDataSource") != null
                                // END ADDED
                                )
              )
                        {
                                return true;
                        }

                        return false;
                }



                /// <summary>
                /// Gets an list of the data source member names.
                /// </summary>
                /// <param name="dataSource">Data source object to get the members for.</param>
                /// <param name="usedForYValue">Indicates that member will be used for Y values.</param>
                /// <returns>List of member names.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily",
            Justification = "Too large of a code change to justify making this change")]
                static internal ArrayList GetDataSourceMemberNames(object dataSource, bool usedForYValue)
                {
                        ArrayList       names = new ArrayList();
            if (dataSource != null)
            {
                // ADDED: for VS2005 compatibility, DT Nov 25, 2004
                if (dataSource.GetType().GetInterface("IDataSource") != null)
                {
                    try
                    {
                        MethodInfo m = dataSource.GetType().GetMethod("Select");
                        if (m != null)
                        {
                            if (m.GetParameters().Length == 1)
                            {
                                // SQL derived datasource
                                Type selectArgsType = dataSource.GetType().Assembly.GetType("System.Web.UI.DataSourceSelectArguments", true);
                                ConstructorInfo ci = selectArgsType.GetConstructor(new Type[] { });
                                dataSource = m.Invoke(dataSource, new object[] { ci.Invoke(new object[] { }) });
                            }
                            else
                            {
                                // object data source
                                dataSource = m.Invoke(dataSource, new object[] { });
                            }
                        }
                    }
                    catch (TargetException)
                    {
                    }
                    catch (TargetInvocationException)
                    {
                    }
                }
                // END ADDED

                // Check all DataTable based data souces
                DataTable dataTable = null;

                if (dataSource is DataTable)
                {
                    dataTable = (DataTable)dataSource;
                }
                else if (dataSource is DataView)
                {
                    dataTable = ((DataView)dataSource).Table;
                }
                else if (dataSource is DataSet && ((DataSet)dataSource).Tables.Count > 0)
                {
                    dataTable = ((DataSet)dataSource).Tables[0];
                }
                else if (dataSource is System.Data.OleDb.OleDbDataAdapter)
                {
                    dataTable = new DataTable();
                    dataTable.Locale = CultureInfo.CurrentCulture;
                    dataTable = ((System.Data.OleDb.OleDbDataAdapter)dataSource).FillSchema(dataTable, SchemaType.Mapped);
                }
                else if (dataSource is System.Data.SqlClient.SqlDataAdapter)
                {
                    dataTable = new DataTable();
                    dataTable.Locale = CultureInfo.CurrentCulture;
                    dataTable = ((System.Data.SqlClient.SqlDataAdapter)dataSource).FillSchema(dataTable, SchemaType.Mapped);
                }
                else if (dataSource is System.Data.OleDb.OleDbDataReader)
                {
                    // Add table columns names
                    for (int fieldIndex = 0; fieldIndex < ((System.Data.OleDb.OleDbDataReader)dataSource).FieldCount; fieldIndex++)
                    {
                        if (!usedForYValue || ((System.Data.OleDb.OleDbDataReader)dataSource).GetFieldType(fieldIndex) != typeof(string))
                        {
                            names.Add(((System.Data.OleDb.OleDbDataReader)dataSource).GetName(fieldIndex));
                        }
                    }
                }
                else if (dataSource is System.Data.SqlClient.SqlDataReader)
                {
                    // Add table columns names
                    for (int fieldIndex = 0; fieldIndex < ((System.Data.SqlClient.SqlDataReader)dataSource).FieldCount; fieldIndex++)
                    {
                        if (!usedForYValue || ((System.Data.SqlClient.SqlDataReader)dataSource).GetFieldType(fieldIndex) != typeof(string))
                        {
                            names.Add(((System.Data.SqlClient.SqlDataReader)dataSource).GetName(fieldIndex));
                        }
                    }
                }
                else if (dataSource is System.Data.OleDb.OleDbCommand)
                {
                    System.Data.OleDb.OleDbCommand command = (System.Data.OleDb.OleDbCommand)dataSource;
                    if (command.Connection != null)
                    {
                        command.Connection.Open();
                        System.Data.OleDb.OleDbDataReader dataReader = command.ExecuteReader();
                        if (dataReader.Read())
                        {
                            for (int fieldIndex = 0; fieldIndex < dataReader.FieldCount; fieldIndex++)
                            {
                                if (!usedForYValue || dataReader.GetFieldType(fieldIndex) != typeof(string))
                                {
                                    names.Add(dataReader.GetName(fieldIndex));
                                }
                            }
                        }

                        dataReader.Close();
                        command.Connection.Close();
                    }
                }
                else if (dataSource is System.Data.SqlClient.SqlCommand)
                {
                    System.Data.SqlClient.SqlCommand command = (System.Data.SqlClient.SqlCommand)dataSource;
                    if (command.Connection != null)
                    {
                        command.Connection.Open();
                        System.Data.SqlClient.SqlDataReader dataReader = command.ExecuteReader();
                        if (dataReader.Read())
                        {
                            for (int fieldIndex = 0; fieldIndex < dataReader.FieldCount; fieldIndex++)
                            {
                                if (!usedForYValue || dataReader.GetFieldType(fieldIndex) != typeof(string))
                                {
                                    names.Add(dataReader.GetName(fieldIndex));
                                }
                            }
                        }

                        dataReader.Close();
                        command.Connection.Close();
                    }
                }


                // Check if DataTable was set
                if (dataTable != null)
                {
                    // Add table columns names
                    foreach (DataColumn column in dataTable.Columns)
                    {
                        if (!usedForYValue || column.DataType != typeof(string))
                        {
                            names.Add(column.ColumnName);
                        }
                    }
                }

                else if (names.Count == 0 && dataSource is ITypedList)
                {
                    foreach (PropertyDescriptor pd in ((ITypedList)dataSource).GetItemProperties(null))
                    {
                        if (!usedForYValue || pd.PropertyType != typeof(string))
                        {
                            names.Add(pd.Name);
                        }
                    }
                }
                else if (names.Count == 0 && dataSource is IEnumerable)
                {
                    // .Net 2.0 ObjectDataSource processing
                    IEnumerator e = ((IEnumerable)dataSource).GetEnumerator();
                    e.Reset();
                    e.MoveNext();
                    foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(e.Current))
                    {
                        if (!usedForYValue || pd.PropertyType != typeof(string))
                        {
                            names.Add(pd.Name);
                        }

                    }
                }



                // Check if list still empty
                if (names.Count == 0)
                {
                    // Add first column or any data member name
                    names.Add("0");
                }

            }

                        return names;
                }

                /// <summary>
                /// Data binds control to the data source
                /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily",
            Justification="Too large of a code change to justify making this change")]
        internal void DataBind()
        {
            // Set bound flag
            this.boundToDataSource = true;

            object dataSource = this.DataSource;
            if (dataSource != null)
            {

                // Convert data adapters to command object
                if (dataSource is System.Data.OleDb.OleDbDataAdapter)
                {
                    dataSource = ((System.Data.OleDb.OleDbDataAdapter)dataSource).SelectCommand;
                }
                else if (dataSource is System.Data.SqlClient.SqlDataAdapter)
                {
                    dataSource = ((System.Data.SqlClient.SqlDataAdapter)dataSource).SelectCommand;
                }

                // Convert data source to recognizable source for the series
                if (dataSource is DataSet && ((DataSet)dataSource).Tables.Count > 0)
                {
                    dataSource = ((DataSet)dataSource).DefaultViewManager.CreateDataView(((DataSet)dataSource).Tables[0]);

                }
                else if (dataSource is DataTable)
                {
                    dataSource = new DataView((DataTable)dataSource);
                }
                else if (dataSource is System.Data.OleDb.OleDbCommand)
                {
                    System.Data.OleDb.OleDbCommand command = (System.Data.OleDb.OleDbCommand)dataSource;
                    command.Connection.Open();
                    System.Data.OleDb.OleDbDataReader dataReader = command.ExecuteReader();

                    this.DataBind(dataReader, null);

                    dataReader.Close();
                    command.Connection.Close();
                    return;
                }
                else if (dataSource is System.Data.SqlClient.SqlCommand)
                {
                    System.Data.SqlClient.SqlCommand command = (System.Data.SqlClient.SqlCommand)dataSource;
                    command.Connection.Open();
                    System.Data.SqlClient.SqlDataReader dataReader = command.ExecuteReader();

                    this.DataBind(dataReader, null);

                    dataReader.Close();
                    command.Connection.Close();
                    return;
                }
                else if (dataSource is IList)
                {
                    dataSource = dataSource as IList;
                }
                else if (dataSource is IListSource  )
                {
                    if (((IListSource)dataSource).ContainsListCollection && ((IListSource)dataSource).GetList().Count > 0)
                    {
                        dataSource = ((IListSource)dataSource).GetList()[0] as IEnumerable;
                    }
                    else
                    {
                        dataSource = ((IListSource)dataSource).GetList();
                    }
                }
                else
                {
                    dataSource = dataSource as IEnumerable;
                }

                // Data bind
                DataBind(dataSource as IEnumerable, null);
            }
        }

                /// <summary>
                /// Data binds control to the data source
                /// </summary>
                /// <param name="dataSource">Data source to bind to.</param>
                /// <param name="seriesList">List of series to bind.</param>
                internal void DataBind(IEnumerable dataSource, ArrayList seriesList)
                {
                        // Data bind series
                        if(dataSource != null && this.Common != null)
                        {
                                //************************************************************
                                //** If list of series is not provided - bind all of them.
                                //************************************************************
                                if(seriesList == null)
                                {
                                        seriesList = new ArrayList();
                                        foreach(Series series in this.Common.Chart.Series)
                                        {
                        // note: added for design time data binding
                        if (this.Common.Chart.IsDesignMode())
                        {
                            if (series.YValueMembers.Length > 0)
                            {
                                seriesList.Add(series);
                            }
                        }
                        else
                        {
                            seriesList.Add(series);
                        }
                                        }
                                }

                                //************************************************************
                                //** Clear all data points in data bound series
                                //************************************************************
                                foreach(Series series in seriesList)
                                {
                                        if(series.XValueMember.Length > 0 || series.YValueMembers.Length > 0)
                                        {
                                                series.Points.Clear();
                                        }
                                }

                                //************************************************************
                                //** Get and reset data enumerator.
                                //************************************************************
                                IEnumerator     enumerator = dataSource.GetEnumerator();
                                if(enumerator.GetType() != typeof(System.Data.Common.DbEnumerator) )
                                {
                    try
                    {
                        enumerator.Reset();
                    }
                    // Some enumerators may not support Resetting 
                    catch (InvalidOperationException)
                    {
                    }
                    catch (NotImplementedException)
                    {
                    }
                    catch (NotSupportedException)
                    {
                    }
                                }


                                //************************************************************
                                //** Loop through the enumerator.
                                //************************************************************
                                bool    valueExsists = true;
                                bool    autoDetectType = true;
                                do
                                {
                                        // Move to the next item
                                        valueExsists = enumerator.MoveNext();

                                        // Loop through all series 
                                        foreach(Series series in seriesList)
                                        {
                                                if(series.XValueMember.Length > 0 || series.YValueMembers.Length > 0)
                                                {
                                                        //************************************************************
                                                        //** Check and convert fields names.
                                                        //************************************************************

                                                        // Convert comma separated field names string to array of names
                                                        string[] yFieldNames = null;
                                                        if(series.YValueMembers.Length > 0)
                                                        {
                                                                yFieldNames = series.YValueMembers.Replace(",,", "\n").Split(',');
                                                                for(int index = 0; index < yFieldNames.Length; index++)
                                                                {
                                                                        yFieldNames[index] = yFieldNames[index].Replace("\n", ",").Trim();
                                                                }
                                                        }
                        
                                                        // Double check that a string object is not provided for data binding
                                                        if(dataSource is string)
                                                        {
                                throw (new ArgumentException(SR.ExceptionDataBindYValuesToString, "dataSource"));
                                                        }

                                                        // Check number of fields
                                                        if(yFieldNames == null || yFieldNames.GetLength(0) > series.YValuesPerPoint)
                                                        {
                                                                throw(new ArgumentOutOfRangeException("dataSource", SR.ExceptionDataPointYValuesCountMismatch(series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture) ) ) );
                                                        }

                                                        //************************************************************
                                                        //** Create new data point.
                                                        //************************************************************
                                                        if(valueExsists)
                                                        {
                                                                // Auto detect values type
                                                                if(autoDetectType)
                                                                {
                                                                        autoDetectType = false;

                                                                        // Make sure Y field is not empty
                                                                        string  yField = yFieldNames[0];
                                                                        int             fieldIndex = 1;
                                                                        while(yField.Length == 0 && fieldIndex < yFieldNames.Length)
                                                                        {
                                                                                yField = yFieldNames[fieldIndex++];
                                                                        }

                                                                        DataPointCollection.AutoDetectValuesType(series, enumerator, series.XValueMember.Trim(), enumerator, yField);
                                                                }


                                                                // Create new point
                                                                DataPoint       newDataPoint = new DataPoint(series);
                                                                bool            emptyValues = false;
                                                                bool            xValueIsNull = false;
                                                                
                                                                //************************************************************
                                                                //** Get new point X and Y values.
                                                                //************************************************************
                                                                object[]        yValuesObj = new object[yFieldNames.Length];
                                                                object          xValueObj = null;

                                                                // Set X to the value provided or use sequence numbers starting with 1
                                                                if(series.XValueMember.Length > 0)
                                                                {
                                                                        xValueObj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, series.XValueMember.Trim());
                                                                        if(xValueObj is System.DBNull || xValueObj == null)
                                                                        {
                                                                                xValueIsNull = true;
                                                                                emptyValues = true;
                                                                                xValueObj = 0.0;
                                                                        }
                                                                }

                                                                if(yFieldNames.Length == 0)
                                                                {
                                                                        yValuesObj[0] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, null);
                                                                        if(yValuesObj[0] is System.DBNull || yValuesObj[0] == null)
                                                                        {
                                                                                emptyValues = true;
                                                                                yValuesObj[0] = 0.0;
                                                                        }
                                                                }
                                                                else
                                                                {
                                                                        for(int i = 0; i < yFieldNames.Length; i++)
                                                                        {
                                                                                if(yFieldNames[i].Length > 0)
                                                                                {
                                                                                        yValuesObj[i] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, yFieldNames[i]);
                                                                                        if(yValuesObj[i] is System.DBNull || yValuesObj[i] == null)
                                                                                        {
                                                                                                emptyValues = true;
                                                                                                yValuesObj[i] = 0.0;
                                                                                        }
                                                                                }
                                                                                else
                                                                                {
                                                                                        yValuesObj[i] = (((Series)seriesList[0]).IsYValueDateTime()) ? DateTime.Now.Date.ToOADate() : 0.0;
                                                                                }
                                                                        }
                                                                }


                                                                // Add data point if X value is not Null
                                                                if(!xValueIsNull)
                                                                {
                                                                        if(emptyValues)
                                                                        {
                                                                                if(xValueObj != null)
                                                                                {
                                                                                        newDataPoint.SetValueXY(xValueObj, yValuesObj);
                                                                                }
                                                                                else
                                                                                {
                                                                                        newDataPoint.SetValueXY(0, yValuesObj);
                                                                                }
                                                                                series.Points.DataPointInit(ref newDataPoint);
                                                                                newDataPoint.IsEmpty = true;
                                                                                series.Points.Add(newDataPoint);
                                                                        }
                                                                        else
                                                                        {
                                                                                if(xValueObj != null)
                                                                                {
                                                                                        newDataPoint.SetValueXY(xValueObj, yValuesObj);
                                                                                }
                                                                                else
                                                                                {
                                                                                        newDataPoint.SetValueXY(0, yValuesObj);
                                                                                }
                                                                                series.Points.DataPointInit(ref newDataPoint);
                                                                                series.Points.Add(newDataPoint);
                                                                        }
                                                                }
                                if (this.Common.Chart.IsDesignMode())
                                {
                                    series["TempDesignData"] = "true";
                                }
                                                        }
                                                }
                                        }
                                
                                } while(valueExsists);

                        }
                }


                /// <summary>
                /// Aligns data points using their axis labels.
                /// </summary>
                /// <param name="sortAxisLabels">Indicates if points should be sorted by axis labels.</param>
                /// <param name="sortingOrder">Sorting pointSortOrder.</param>
                internal void AlignDataPointsByAxisLabel(bool sortAxisLabels, PointSortOrder sortingOrder)
                {
                        // Find series which are attached to the same X axis in the same chart area
                        foreach(ChartArea chartArea in this.ChartAreas)
                        {

                                // Check if chart area is visible
                                if(chartArea.Visible)

                                {
                                        // Create series list for primary and secondary X axis
                                        ArrayList chartAreaSeriesPrimary = new ArrayList();
                                        ArrayList chartAreaSeriesSecondary = new ArrayList();
                                        foreach(Series series in this.Common.Chart.Series)
                                        {
                        // Check if series belongs to the chart area
                        if (series.ChartArea == chartArea.Name)
                                                {
                                                        if(series.XSubAxisName.Length == 0)
                                                        {
                                                                if(series.XAxisType == AxisType.Primary)
                                                                {
                                                                        chartAreaSeriesPrimary.Add(series);
                                                                }
                                                                else
                                                                {
                                                                        chartAreaSeriesSecondary.Add(series);
                                                                }
                                                        }
                                                }
                                        }

                                        // Align series
                                        AlignDataPointsByAxisLabel(chartAreaSeriesPrimary, sortAxisLabels, sortingOrder);
                                        AlignDataPointsByAxisLabel(chartAreaSeriesSecondary, sortAxisLabels, sortingOrder);
                                }
                        }
                }

                /// <summary>
                /// Aligns data points using their axis labels.
                /// </summary>
                /// <param name="seriesList">List of series to align.</param>
                /// <param name="sortAxisLabels">Indicates if points should be sorted by axis labels.</param>
                /// <param name="sortingOrder">Sorting order.</param>
                internal void AlignDataPointsByAxisLabel(
                        ArrayList seriesList, 
                        bool sortAxisLabels, 
                        PointSortOrder sortingOrder)
                {
                        // List is empty
                        if(seriesList.Count == 0)
                        {
                                return;
                        }

                        // Collect information about all points in all series
                        bool            indexedX = true;
                        bool            uniqueAxisLabels = true;
                        ArrayList       axisLabels = new ArrayList();
                        foreach(Series series in seriesList)
                        {
                                ArrayList       seriesAxisLabels = new ArrayList();
                                foreach(DataPoint point in series.Points)
                                {
                                        // Check if series has indexed X values
                                        if(!series.IsXValueIndexed && point.XValue != 0.0)
                                        {
                                                indexedX = false;
                                                break;
                                        }

                                        // Add axis label to the list and make sure it's non-empty and unique
                                        if(point.AxisLabel.Length == 0)
                                        {
                                                uniqueAxisLabels = false;
                                                break;
                                        }
                                        else if(seriesAxisLabels.Contains(point.AxisLabel))
                                        {
                                                uniqueAxisLabels = false;
                                                break;
                                        }
                                        else if(!axisLabels.Contains(point.AxisLabel))
                                        {
                                                axisLabels.Add(point.AxisLabel);
                                        }

                                        seriesAxisLabels.Add(point.AxisLabel);
                                }
                        }

                        // Sort axis labels
                        if(sortAxisLabels)
                        {
                                axisLabels.Sort();
                                if(sortingOrder == PointSortOrder.Descending)
                                {
                                        axisLabels.Reverse();
                                }
                        }

                        // All series must be indexed
                        if(!indexedX)
                        {
                throw (new InvalidOperationException(SR.ExceptionChartDataPointsAlignmentFaild));
                        }

                        // AxisLabel can't be empty or duplicated
                        if(!uniqueAxisLabels)
                        {
                throw (new InvalidOperationException(SR.ExceptionChartDataPointsAlignmentFaildAxisLabelsInvalid));
                        }

                        // Assign unique X values for data points in all series with same axis LabelStyle
                        if(indexedX && uniqueAxisLabels)
                        {
                                foreach(Series series in seriesList)
                                {
                                        foreach(DataPoint point in series.Points)
                                        {
                                                point.XValue = axisLabels.IndexOf(point.AxisLabel) + 1;
                                        }

                                        // Sort points by X value
                                        series.Sort(PointSortOrder.Ascending, "X");
                                }

                                // Make sure ther are no missing points
                                foreach(Series series in seriesList)
                                {
                                        series.IsXValueIndexed = true;
                                        for(int index = 0; index < axisLabels.Count; index++)
                                        {
                                                if(index >= series.Points.Count ||
                                                        series.Points[index].XValue != index + 1)
                                                {
                                                        DataPoint newPoint = new DataPoint(series);
                                                        newPoint.AxisLabel = (string)axisLabels[index];
                                                        newPoint.XValue = index + 1;
                                                        newPoint.YValues[0] = 0.0;
                                                        newPoint.IsEmpty = true;
                                                        series.Points.Insert(index, newPoint);
                                                }
                                        }
                                }

                        }

                }

        /// <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="sort">Indicates that series should be sorted by group field.</param>
        /// <param name="sortingOrder">Series sorting order by group field.</param>
                internal void DataBindCrossTab(
                        IEnumerable dataSource, 
                        string seriesGroupByField, 
                        string xField, 
                        string yFields, 
                        string otherFields,
                        bool sort,
                        PointSortOrder sortingOrder)
                {
            // Check arguments
            if (dataSource == null)
                throw (new ArgumentNullException("dataSource", SR.ExceptionDataPointInsertionNoDataSource));

            if (dataSource is string)
                throw (new ArgumentException(SR.ExceptionDataBindSeriesToString, "dataSource"));

            if (String.IsNullOrEmpty(yFields))
                throw (new ArgumentException(SR.ExceptionChartDataPointsInsertionFailedYValuesEmpty, "yFields"));

            if (String.IsNullOrEmpty(seriesGroupByField))
                throw (new ArgumentException(SR.ExceptionDataBindSeriesGroupByParameterIsEmpty, "seriesGroupByField"));

            
            // List of series and group by field values
                        ArrayList seriesList = new ArrayList();
                        ArrayList groupByValueList = new ArrayList();

                        // Convert comma separated Y values field names string to array of names
                        string[] yFieldNames = null;
                        if(yFields != null)
                        {
                                yFieldNames = yFields.Replace(",,", "\n").Split(',');
                                for(int index = 0; index < yFieldNames.Length; index++)
                                {
                                        yFieldNames[index] = yFieldNames[index].Replace("\n", ",");
                                }
                        }

                        // Convert other fields/properties names to two arrays of names
                        string[] otherAttributeNames = null;
                        string[] otherFieldNames = null;
                        string[] otherValueFormat = null;
                        DataPointCollection.ParsePointFieldsParameter(
                                otherFields,
                                ref otherAttributeNames,
                                ref otherFieldNames,
                                ref otherValueFormat);
                        

                        // Get and reset enumerator
                        IEnumerator     enumerator = DataPointCollection.GetDataSourceEnumerator(dataSource);
                        if(enumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
                        {
                try
                {
                    enumerator.Reset();
                }
                // Some enumerators may not support Resetting 
                catch (NotSupportedException)
                {
                }
                catch (NotImplementedException)
                {
                }
                catch (InvalidOperationException)
                {
                }

                        }

                        // Add data points
                        bool            valueExsist = true;
                        object[]        yValuesObj = new object[yFieldNames.Length];
                        object          xValueObj = null;
                        bool            autoDetectType = true;

                        do 
                        {
                                // Move to the next objects in the enumerations
                                if(valueExsist)
                                {
                                        valueExsist = enumerator.MoveNext();
                                }

                                // Create and initialize data point
                                if(valueExsist)
                                {
                                        // Get value of the group by field
                                        object groupObj = DataPointCollection.ConvertEnumerationItem(
                                                enumerator.Current, 
                                                seriesGroupByField);

                                        // Check series group by field and create new series if required
                                        Series series = null;
                                        int seriesIndex = groupByValueList.IndexOf(groupObj);
                                        if(seriesIndex >= 0)
                                        {
                                                // Select existing series from the list
                                                series = (Series)seriesList[seriesIndex];
                                        }
                                        else
                                        {
                                                // Create new series
                                                series = new Series();
                                                series.YValuesPerPoint = yFieldNames.GetLength(0);

                                                // If not the first series in the list copy some properties
                                                if(seriesList.Count > 0)
                                                {
                                                        series.XValueType = ((Series)seriesList[0]).XValueType;
                                                        series.autoXValueType = ((Series)seriesList[0]).autoXValueType;
                                                        series.YValueType = ((Series)seriesList[0]).YValueType;
                                                        series.autoYValueType = ((Series)seriesList[0]).autoYValueType;
                                                }

                                                // Try to set series name based on grouping vlaue
                        string groupObjStr = groupObj as string;
                                                if(groupObjStr != null)
                                                {
                            series.Name = groupObjStr;
                                                }
                                                else
                                                {
                                                        series.Name = seriesGroupByField + " - " + groupObj.ToString();
                                                }
                                                
                                        
                                                // Add series and group value into the lists
                                                groupByValueList.Add(groupObj);
                                                seriesList.Add(series);
                                        }

                                        
                                        // Auto detect valu(s) type
                                        if(autoDetectType)
                                        {
                                                autoDetectType = false;
                                                DataPointCollection.AutoDetectValuesType(series, enumerator, xField, enumerator, yFieldNames[0]);
                                        }

                                        // Create new data point
                                        DataPoint       newDataPoint = new DataPoint(series);
                                        bool            emptyValues = false;

                                        // Set X to the value provided
                                        if(xField.Length > 0)
                                        {
                                                xValueObj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, xField);
                                                if( DataPointCollection.IsEmptyValue(xValueObj) )
                                                {
                                                        emptyValues = true;
                                                        xValueObj = 0.0;
                                                }
                                        }

                                        // Set Y values
                                        if(yFieldNames.Length == 0)
                                        {
                                                yValuesObj[0] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, null);
                                                if( DataPointCollection.IsEmptyValue(yValuesObj[0]) )
                                                {
                                                        emptyValues = true;
                                                        yValuesObj[0] = 0.0;
                                                }
                                        }
                                        else
                                        {
                                                for(int i = 0; i < yFieldNames.Length; i++)
                                                {
                                                        yValuesObj[i] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, yFieldNames[i]);
                                                        if( DataPointCollection.IsEmptyValue(yValuesObj[i] ) )
                                                        {
                                                                emptyValues = true;
                                                                yValuesObj[i] = 0.0;
                                                        }
                                                }
                                        }

                                        // Set other values
                                        if(otherAttributeNames != null && 
                                                otherAttributeNames.Length > 0)
                                        {
                                                for(int i = 0; i < otherFieldNames.Length; i++)
                                                {
                                                        // Get object by field name
                                                        object obj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, otherFieldNames[i]);
                                                        if( !DataPointCollection.IsEmptyValue( obj ) )
                                                        {
                                                                newDataPoint.SetPointCustomProperty(
                                                                        obj, 
                                                                        otherAttributeNames[i], 
                                                                        otherValueFormat[i]);
                                                        }
                                                }
                                        }

                                        // IsEmpty value was detected
                                        if(emptyValues)
                                        {
                                                if(xValueObj != null)
                                                {
                                                        newDataPoint.SetValueXY(xValueObj, yValuesObj);
                                                }
                                                else
                                                {
                                                        newDataPoint.SetValueXY(0, yValuesObj);
                                                }
                                                DataPointCollection.DataPointInit(series, ref newDataPoint);
                                                newDataPoint.IsEmpty = true;
                                                series.Points.Add(newDataPoint);
                                        }
                                        else
                                        {
                                                if(xValueObj != null)
                                                {
                                                        newDataPoint.SetValueXY(xValueObj, yValuesObj);
                                                }
                                                else
                                                {
                                                        newDataPoint.SetValueXY(0, yValuesObj);
                                                }
                        DataPointCollection.DataPointInit(series, ref newDataPoint);
                                                series.Points.Add(newDataPoint);
                                        }
                                }

                        } while(valueExsist);

                        // Sort series usig values of group by field
                        if(sort)
                        {
                                // Duplicate current list
                                ArrayList oldList = (ArrayList)groupByValueList.Clone();

                                // Sort list 
                                groupByValueList.Sort();
                                if(sortingOrder == PointSortOrder.Descending)
                                {
                                        groupByValueList.Reverse();
                                }

                                // Change order of series in collection
                                ArrayList sortedSeriesList = new ArrayList();
                                foreach(object obj in groupByValueList)
                                {
                                        sortedSeriesList.Add(seriesList[oldList.IndexOf(obj)]);
                                }
                                seriesList = sortedSeriesList;
                        }

                        // Add all series from the list into the series collection
                        foreach(Series series in seriesList)
                        {
                                this.Common.Chart.Series.Add(series);
                        }
                }

                /// <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>
        internal void DataBindTable(
            IEnumerable dataSource,
            string xField)
        {
            // Check arguments
            if (dataSource == null)
                throw new ArgumentNullException("dataSource");

            // Get list of member names from the data source
            ArrayList dataSourceFields = GetDataSourceMemberNames(dataSource, true);

            // Remove X value field if it's there
            if (xField != null && xField.Length > 0)
            {
                int index = -1;
                for (int i = 0; i < dataSourceFields.Count; i++)
                {
                    if ( String.Equals((string)dataSourceFields[i], xField, StringComparison.OrdinalIgnoreCase ) )
                    {
                        index = i;
                        break;
                    }
                }
                if (index >= 0)
                {
                    dataSourceFields.RemoveAt(index);
                }
                else
                {
                    // Check if field name passed as index
                    bool parseSucceed = int.TryParse(xField, NumberStyles.Any, CultureInfo.InvariantCulture, out index);
                    if (parseSucceed && index >= 0 && index < dataSourceFields.Count)
                    {
                        dataSourceFields.RemoveAt(index);
                    }
                }
            }

            // Get number of series
            int seriesNumber = dataSourceFields.Count;
            if (seriesNumber > 0)
            {
                // Create as many series as fields in the data source
                ArrayList seriesList = new ArrayList();
                int index = 0;
                foreach (string fieldName in dataSourceFields)
                {
                    Series series = new Series(fieldName);

                    // Set binding properties
                    series.YValueMembers = fieldName;
                    series.XValueMember = xField;

                    // Add to list
                    seriesList.Add(series);
                    ++index;
                }


                // Data bind series
                this.DataBind(dataSource, seriesList);

                // Add all series from the list into the series collection
                foreach (Series series in seriesList)
                {
                    // Clear binding properties
                    series.YValueMembers = String.Empty;
                    series.XValueMember = String.Empty;

                    // Add series into the list
                    this.Common.Chart.Series.Add(series);
                }
            }
        }

                #endregion // Data Binding

        #endregion

    }
        
        /// <summary>
    /// ChartPicture class represents chart content like legends, titles, 
    /// chart areas and series. It provides methods for positioning and 
    /// drawing all chart elements.
        /// </summary>
    internal class ChartPicture : ChartElement, IServiceProvider
        {
        #region Fields

        /// <summary>
                        /// Indicates that chart exceptions should be suppressed.
                        /// </summary>
                        private bool                                    _suppressExceptions = false;

                        // Chart Graphic object
            internal ChartGraphics ChartGraph { get; set; }

                        // Private data members, which store properties values
                        private GradientStyle                   _backGradientStyle = GradientStyle.None;
                        private Color                                   _backSecondaryColor = Color.Empty;
                        private Color                                   _backColor = Color.White;
                        private string                                  _backImage = "";
                        private ChartImageWrapMode              _backImageWrapMode = ChartImageWrapMode.Tile;
                        private Color                                   _backImageTransparentColor = Color.Empty;
                        private ChartImageAlignmentStyle                        _backImageAlign = ChartImageAlignmentStyle.TopLeft;
                        private Color                                   _borderColor = Color.White;
                        private int                                             _borderWidth = 1;
                        private ChartDashStyle                  _borderDashStyle = ChartDashStyle.NotSet;
                        private ChartHatchStyle                 _backHatchStyle = ChartHatchStyle.None;
                        private AntiAliasingStyles              _antiAliasing = AntiAliasingStyles.All;
                        private TextAntiAliasingQuality _textAntiAliasingQuality = TextAntiAliasingQuality.High;
                        private bool                                    _isSoftShadows = true;
                        private int                                             _width = 300;
                        private int                                             _height = 300;
                        private DataManipulator                 _dataManipulator = new DataManipulator();
                        internal HotRegionsList                 hotRegionsList = null;
                        private BorderSkin                  _borderSkin = null;
#if !Microsoft_CONTROL
                        private bool                                    _isMapEnabled = true;
                        private MapAreasCollection              _mapAreas = null;
#endif
            // Chart areas collection
            private ChartAreaCollection     _chartAreas = null;

                        // Chart legend collection
                        private LegendCollection                _legends = null;

                        // Chart title collection
                        private TitleCollection                 _titles = null;

                    // Chart annotation collection
                        private AnnotationCollection    _annotations = null;

                        // Annotation smart labels class
                        internal AnnotationSmartLabel   annotationSmartLabel = new AnnotationSmartLabel();

                        // Chart picture events
            internal event EventHandler<ChartPaintEventArgs> BeforePaint;
            internal event EventHandler<ChartPaintEventArgs> AfterPaint;

                        // Chart title position rectangle
                        private RectangleF                              _titlePosition = RectangleF.Empty;

                        // Element spacing size
                        internal const float                    elementSpacing = 3F;

                        // Maximum size of the font in percentage
                        internal const float                    maxTitleSize = 15F;

                        // Printing indicator
                        internal bool                                   isPrinting = false;

                        // Indicates chart selection mode
                        internal bool                                   isSelectionMode = false;

            private FontCache               _fontCache = new FontCache();
            
                        // Position of the chart 3D border
                        private RectangleF                              _chartBorderPosition = RectangleF.Empty;

#if Microsoft_CONTROL

                        // Saving As Image indicator
                        internal bool                                   isSavingAsImage = false;

            // Indicates that chart background is restored from the double buffer
                        // prior to drawing top level objects like annotations, cursors and selection.
                        internal bool                                   backgroundRestored = false;

            // Buffered image of non-top level chart elements
                    internal            Bitmap                          nonTopLevelChartBuffer = null;

#endif // Microsoft_CONTROL

        #endregion

            #region Constructors

            /// <summary>
                /// Constructor.
                /// </summary>
                /// <param name="container">Service container</param>
                public ChartPicture(IServiceContainer container) 
                {
                        if(container == null)
                        {
                                throw(new ArgumentNullException(SR.ExceptionInvalidServiceContainer));
                        }

                        // Create and set Common Elements
            Common = new CommonElements(container);
                        ChartGraph= new ChartGraphics(Common);
                        hotRegionsList = new HotRegionsList(Common);

                        // Create border properties class
                        _borderSkin = new BorderSkin(this);

                        // Create a collection of chart areas
                        _chartAreas = new ChartAreaCollection(this);

                        // Create a collection of legends
                        _legends = new LegendCollection(this);

                        // Create a collection of titles
                        _titles = new TitleCollection(this);

                        // Create a collection of annotations
                        _annotations = new AnnotationCollection(this);

                        // Set Common elements for data manipulator
                        _dataManipulator.Common = Common;

#if !Microsoft_CONTROL
                        // Create map areas collection
                        _mapAreas = new MapAreasCollection();
#endif
        }

                /// <summary>
                /// Returns Chart service object
                /// </summary>
                /// <param name="serviceType">Service AxisName</param>
                /// <returns>Chart picture</returns>
                [EditorBrowsableAttribute(EditorBrowsableState.Never)]
                object IServiceProvider.GetService(Type serviceType)
                {
                        if(serviceType == typeof(ChartPicture))
                        {
                                return this;
                        }
                        throw (new ArgumentException( SR.ExceptionChartPictureUnsupportedType( serviceType.ToString() ) ) );
                }

                #endregion

                #region Painting and selection methods

        /// <summary>
        /// Performs empty painting.
        /// </summary>
        internal void PaintOffScreen()
        {
            // Check chart size
            // NOTE: Fixes issue #4733
            if (this.Width <= 0 || this.Height <= 0)
            {
                return;
            }
            
            // Set process Mode to hot regions
            this.Common.HotRegionsList.ProcessChartMode |= ProcessMode.HotRegions;
#if Microsoft_CONTROL
            this.Common.HotRegionsList.hitTestCalled = true;
#endif // Microsoft_CONTROL

            // Enable selection mode
            this.isSelectionMode = true;

            // Hot Region list does not exist. Create the list.
            //this.common.HotRegionsList.List = new ArrayList();
            this.Common.HotRegionsList.Clear();

            // Create a new bitmap
            Bitmap image = new Bitmap(Math.Max(1,Width), Math.Max(1,Height));

            // Creates a new Graphics object from the 
            // specified Image object.
            Graphics offScreen = Graphics.FromImage(image);

            // Connect Graphics object with Chart Graphics object
            ChartGraph.Graphics = offScreen;

            // Remember the previous dirty flag
#if Microsoft_CONTROL                   
                        bool oldDirtyFlag = this.Common.Chart.dirtyFlag;
#endif //Microsoft_CONTROL


            Paint(ChartGraph.Graphics, false);

            image.Dispose();

            // Restore the previous dirty flag
#if Microsoft_CONTROL                   
                        this.Common.Chart.dirtyFlag = oldDirtyFlag;
#endif //Microsoft_CONTROL

            // Disable selection mode
            this.isSelectionMode = false;

                        // Set process Mode to hot regions
                        this.Common.HotRegionsList.ProcessChartMode |= ProcessMode.HotRegions;

        }

                /// <summary>
                /// Gets text rendering quality.
                /// </summary>
                /// <returns>Text rendering quality.</returns>
                internal TextRenderingHint GetTextRenderingHint()
                {
                        TextRenderingHint result = TextRenderingHint.SingleBitPerPixelGridFit;
                        if( (this.AntiAliasing & AntiAliasingStyles.Text) == AntiAliasingStyles.Text )
                        {
                                result = TextRenderingHint.ClearTypeGridFit;
                                if(this.TextAntiAliasingQuality == TextAntiAliasingQuality.Normal)
                                {
                                        result = TextRenderingHint.AntiAlias;
                                }
                                else if(this.TextAntiAliasingQuality == TextAntiAliasingQuality.SystemDefault)
                                {
                                        result = TextRenderingHint.SystemDefault;
                                }
                        }
                        else
                        {
                                result = TextRenderingHint.SingleBitPerPixelGridFit;
                        }

                        return result;
                }

        internal bool GetBorderSkinVisibility()
        {
            return _borderSkin.SkinStyle != BorderSkinStyle.None && this.Width > 20 && this.Height > 20;
        }

        /// <summary>
        /// This function paints a chart.
        /// </summary>
        /// <param name="graph">The graph provides drawing object to the display device. A Graphics object is associated with a specific device context.</param>
        /// <param name="paintTopLevelElementOnly">Indicates that only chart top level elements like cursors, selection or annotation objects must be redrawn.</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "3#svg")]
        internal void Paint( 
                        Graphics graph, 
                        bool paintTopLevelElementOnly )
                {

#if Microsoft_CONTROL

                        // Reset restored and saved backgound flags
                        this.backgroundRestored = false;

#endif // Microsoft_CONTROL

                        // Reset Annotation Smart Labels 
                        this.annotationSmartLabel.Reset();

            // Do not draw the control if size is less than 5 pixel
            if (this.Width < 5 || this.Height < 5)
            {
                return;
            }

#if Microsoft_CONTROL

                        bool    resetHotRegionList = false;
            
                        if( 
                this.Common.HotRegionsList.hitTestCalled 
                || IsToolTipsEnabled() 
                )
                        {
                                Common.HotRegionsList.ProcessChartMode = ProcessMode.HotRegions | ProcessMode.Paint;

                                this.Common.HotRegionsList.hitTestCalled = false;

                                // Clear list of hot regions 
                                if(paintTopLevelElementOnly)
                                {
                                        // If repainting only top level elements (annotations) - 
                                        // clear top level objects hot regions only
                                        for(int index = 0; index < this.Common.HotRegionsList.List.Count; index++)
                                        {
                                                HotRegion region = (HotRegion)this.Common.HotRegionsList.List[index];
                                                if(region.Type == ChartElementType.Annotation)
                                                {
                                                        this.Common.HotRegionsList.List.RemoveAt(index);
                                                        --index;
                                                }
                    }
                                }
                                else
                                {
                                        // If repainting whole chart - clear all hot regions
                                        resetHotRegionList = true;
                                }
                        }
                        else
                        {
                                Common.HotRegionsList.ProcessChartMode = ProcessMode.Paint;

                                // If repainting whole chart - clear all hot regions
                                resetHotRegionList = true;
                        }

                        // Reset hot region list
                        if(resetHotRegionList)
                        {
                                this.Common.HotRegionsList.Clear();
                        }
                        
#else
                        if( this.IsMapEnabled )
                        {
                                Common.HotRegionsList.ProcessChartMode |= ProcessMode.ImageMaps | ProcessMode.Paint;
                                
                                // Clear any existing non-custom image map areas
                                for(int index = 0; index < this.MapAreas.Count; index++)
                                {
                                        MapArea mapArea = this.MapAreas[index];
                                        if(!mapArea.IsCustom)
                                        {
                                                this.MapAreas.RemoveAt(index);
                                                --index;
                                        }
                                }
                        }


#endif  //#if Microsoft_CONTROL

                        // Check if control was data bound
                        ChartImage chartImage = this as ChartImage;
                        if(chartImage != null && !chartImage.boundToDataSource)
                        {
                                if(this.Common != null && this.Common.Chart != null && !this.Common.Chart.IsDesignMode())
                                {
                                        this.Common.Chart.DataBind();
                                }
                        }

            // Connect Graphics object with Chart Graphics object
                        ChartGraph.Graphics = graph;

                        Common.graph = ChartGraph;

                        // Set anti alias mode
                        ChartGraph.AntiAliasing = _antiAliasing;
                        ChartGraph.softShadows = _isSoftShadows;
                        ChartGraph.TextRenderingHint = GetTextRenderingHint();

                        try
                        {
                                // Check if only chart area cursors and annotations must be redrawn
                                if(!paintTopLevelElementOnly)
                                {
                                        // Fire Before Paint event
                                        OnBeforePaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));

                                        // Flag indicates that resize method should be called 
                                        // after adjusting the intervals in 3D charts
                                        bool    resizeAfterIntervalAdjusting = false;

                                        // RecalculateAxesScale paint chart areas
                                        foreach (ChartArea area in _chartAreas )
                                        {

                                                // Check if area is visible
                                                if(area.Visible)

                                                {
                                                        area.Set3DAnglesAndReverseMode();
                                                        area.SetTempValues();
                                                        area.ReCalcInternal();

                                                        // Resize should be called the second time
                                                        if( area.Area3DStyle.Enable3D && !area.chartAreaIsCurcular)
                                                        {
                                                                resizeAfterIntervalAdjusting = true;
                                                        }
                                                }
                                        }

                                        // Call Customize event
                    this.Common.Chart.CallOnCustomize();

                                        // Resize picture
                                        Resize(ChartGraph, resizeAfterIntervalAdjusting);

                                
                                        // This code is introduce because labels has to 
                                        // be changed when scene is rotated.
                    bool intervalReCalculated = false;
                                        foreach (ChartArea area in _chartAreas )
                                        {
                                                if( area.Area3DStyle.Enable3D  && 
                                                        !area.chartAreaIsCurcular

                                                        && area.Visible

                                                        )

                                                {
                                                        // Make correction for interval in 3D space
                            intervalReCalculated = true;
                                                        area.Estimate3DInterval( ChartGraph );
                                                        area.ReCalcInternal();
                                                }
                                        }

                                        // Resize chart areas after updating 3D interval
                                        if(resizeAfterIntervalAdjusting)
                                        {
                        // NOTE: Fixes issue #6808.
                        // In 3D chart area interval will be changed to compenstae for the axis rotation angle.
                        // This will cause all standard labels to be changed. We need to call the customize event 
                        // the second time to give user a chance to modify those labels.
                        if (intervalReCalculated)
                        {
                            // Call Customize event
                            this.Common.Chart.CallOnCustomize();
                        }

                        // Resize chart elements
                        Resize(ChartGraph);
                                        }


                                        //***********************************************************************
                                        //** Draw chart 3D border
                                        //***********************************************************************
                    if (GetBorderSkinVisibility())
                                        {
                                                // Fill rectangle with page color
                                                ChartGraph.FillRectangleAbs( new RectangleF( 0, 0, Width-1 , Height-1 ), 
                                                        _borderSkin.PageColor, 
                                                        ChartHatchStyle.None, 
                                                        "", 
                                                        ChartImageWrapMode.Tile,
                                                        Color.Empty,
                                                        ChartImageAlignmentStyle.Center,
                                                        GradientStyle.None, 
                                                        Color.Empty, 
                                                        _borderSkin.PageColor, 
                                                        1, 
                                                        ChartDashStyle.Solid,
                                                        PenAlignment.Inset );

                                                // Draw 3D border
                                                ChartGraph.Draw3DBorderAbs(
                                                        _borderSkin,
                                                        this._chartBorderPosition, 
                                                        BackColor, 
                                                        BackHatchStyle, 
                                                        BackImage, 
                                                        BackImageWrapMode,
                                                        BackImageTransparentColor,
                                                        BackImageAlignment,
                                                        BackGradientStyle, 
                                                        BackSecondaryColor, 
                                                        BorderColor, 
                                                        BorderWidth, 
                                                        BorderDashStyle);
                                        }

                                                // Paint Background
                                        else
                                        {
                                                ChartGraph.FillRectangleAbs( new RectangleF( 0, 0, Width-1 , Height-1 ), 
                                                        BackColor, 
                                                        BackHatchStyle, 
                                                        BackImage, 
                                                        BackImageWrapMode,
                                                        BackImageTransparentColor,
                                                        BackImageAlignment,
                                                        BackGradientStyle, 
                                                        BackSecondaryColor, 
                                                        BorderColor, 
                                                        BorderWidth, 
                                                        BorderDashStyle,
                                                        PenAlignment.Inset );
                                        }

                                        // Call BackPaint event
                    this.Chart.CallOnPrePaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));

                                        // Call paint function for each chart area.
                                        foreach (ChartArea area in _chartAreas )
                                        {

                                                // Check if area is visible
                                                if(area.Visible)

                                                {
                                                        area.Paint(ChartGraph);
                                                }
                                        }

                                        // This code is introduced because of GetPointsInterval method, 
                                        // which is very time consuming. There is no reason to calculate 
                                        // interval after painting.
                                        foreach (ChartArea area in _chartAreas )
                                        {
                                                // Reset interval data
                                                area.intervalData = double.NaN;
                                        }

                                        // Draw Legends
                                        foreach(Legend legendCurrent in this.Legends)
                                        {
                                                legendCurrent.Paint(ChartGraph);
                                        }

                                        // Draw chart titles from the collection
                                        foreach(Title titleCurrent in this.Titles)
                                        {
                                                titleCurrent.Paint(ChartGraph);
                                        }

                                        // Call Paint event
                    this.Chart.CallOnPostPaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));
                                }

                                // Draw annotation objects 
                                this.Annotations.Paint(ChartGraph, paintTopLevelElementOnly);

                                // Draw chart areas cursors in all areas.
                                // Only if not in selection 
                                if(!this.isSelectionMode)
                                {
                                        foreach (ChartArea area in _chartAreas )
                                        {

                                                // Check if area is visible
                                                if(area.Visible)

                                                {
                                                        area.PaintCursors(ChartGraph, paintTopLevelElementOnly);
                                                }
                                        }
                                }

                                // Return default values
                                foreach (ChartArea area in _chartAreas )
                                {

                                        // Check if area is visible
                                        if(area.Visible)

                                        {
                                                area.Restore3DAnglesAndReverseMode();
                                                area.GetTempValues();
                                        }
                                }
            }
                        catch(System.Exception)
                        {
                                throw;
                        }
                        finally
                        {
                                // Fire After Paint event
                                OnAfterPaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));

                                // Restore temp values for each chart area
                                foreach (ChartArea area in _chartAreas )
                                {

                                        // Check if area is visible
                                        if(area.Visible)

                                        {
                                                area.Restore3DAnglesAndReverseMode();
                                                area.GetTempValues();
                                        }
                                }

#if !Microsoft_CONTROL
                if (this.Chart.IsDesignMode())
                {
                    this.Chart.MapAreas.RemoveNonCustom();
                }
#endif //!Microsoft_CONTROL
            }
                }

                /// <summary>
                /// Invoke before paint delegates.
                /// </summary>
                /// <param name="e">Event arguments.</param>
                protected virtual void OnBeforePaint(ChartPaintEventArgs e) 
                {
                        if (BeforePaint != null) 
                        {
                                //Invokes the delegates.
                                BeforePaint(this, e); 
                        }
                }

                /// <summary>
                /// Invoke after paint delegates.
                /// </summary>
                /// <param name="e">Event arguments.</param>
                protected virtual void OnAfterPaint(ChartPaintEventArgs e) 
                {
                        if (AfterPaint != null) 
                        {
                                //Invokes the delegates.
                                AfterPaint(this, e); 
                        }
                }

        internal override void Invalidate()
        {
            base.Invalidate();

#if Microsoft_CONTROL
            if (Chart!=null)
                Chart.Invalidate();
#endif
        }
                #endregion

                #region Resizing methods

                /// <summary>
                /// Resize the chart picture.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                public void Resize(ChartGraphics chartGraph)
                {
                        Resize(chartGraph, false);
                }

                /// <summary>
                /// Resize the chart picture.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="calcAreaPositionOnly">Indicates that only chart area position is calculated.</param>
                public void Resize(ChartGraphics chartGraph, bool calcAreaPositionOnly)
                {
                        // Set the chart size for Common elements
                        Common.Width = _width;
                        Common.Height = _height;

                        // Set the chart size for Chart graphics
                        chartGraph.SetPictureSize( _width, _height );

                        // Initialize chart area(s) rectangle
                        RectangleF      chartAreasRectangle = new RectangleF(0, 0, _width - 1, _height - 1);
                        chartAreasRectangle = chartGraph.GetRelativeRectangle(chartAreasRectangle);

                        //******************************************************
                        //** Get the 3D border interface
                        //******************************************************
                        _titlePosition = RectangleF.Empty;
                        IBorderType     border3D = null;
                        bool    titleInBorder = false;

                        if(_borderSkin.SkinStyle != BorderSkinStyle.None)
                        {
                                // Set border size
                                this._chartBorderPosition = chartGraph.GetAbsoluteRectangle(chartAreasRectangle);

                                // Get border interface 
                                border3D = Common.BorderTypeRegistry.GetBorderType(_borderSkin.SkinStyle.ToString());
                                if(border3D != null)
                                {
                    border3D.Resolution = chartGraph.Graphics.DpiX;
                                        // Check if title should be displayed in the border
                                        titleInBorder = border3D.GetTitlePositionInBorder() != RectangleF.Empty;
                                        _titlePosition = chartGraph.GetRelativeRectangle(border3D.GetTitlePositionInBorder());
                                        _titlePosition.Width = chartAreasRectangle.Width - _titlePosition.Width;

                                        // Adjust are position to the border size
                                        border3D.AdjustAreasPosition(chartGraph, ref chartAreasRectangle);
                                }
                        }

                        //******************************************************
                        //** Calculate position of all titles in the collection
                        //******************************************************
                        RectangleF      frameTitlePosition  = RectangleF.Empty;
                        if(titleInBorder)
                        {
                                frameTitlePosition = new RectangleF(_titlePosition.Location, _titlePosition.Size);
                        }
                        foreach(Title title in this.Titles)
                        {
                if (title.DockedToChartArea == Constants.NotSetValue &&
                                        title.Position.Auto &&
                                        title.Visible)
                                {
                                        title.CalcTitlePosition(chartGraph, ref chartAreasRectangle, ref frameTitlePosition, elementSpacing);
                                }
                        }

                        //******************************************************
                        //** Calculate position of all legends in the collection
                        //******************************************************
                        this.Legends.CalcLegendPosition(chartGraph, ref chartAreasRectangle, elementSpacing);

                        //******************************************************
                        //** Calculate position of the chart area(s)
                        //******************************************************
                        chartAreasRectangle.Width -= elementSpacing;
                        chartAreasRectangle.Height -= elementSpacing;
                        RectangleF areaPosition = new RectangleF();


                        // Get number of chart areas that requeres automatic positioning
                        int     areaNumber = 0;
                        foreach (ChartArea area in _chartAreas )
                        {

                                // Check if area is visible
                                if(area.Visible)

                                {
                                        if(area.Position.Auto)
                                        {
                                                ++areaNumber;
                                        }
                                }
                        }

                        // Calculate how many columns & rows of areas we going to have
                        int     areaColumns = (int)Math.Floor(Math.Sqrt(areaNumber));
                        if(areaColumns < 1)
                        {
                                areaColumns = 1;
                        }
                        int     areaRows = (int)Math.Ceiling(((float)areaNumber) / ((float)areaColumns));

                        // Set position for all areas
                        int     column = 0;
                        int     row = 0;
                        foreach (ChartArea area in _chartAreas )
                        {

                                // Check if area is visible
                                if(area.Visible)

                                {
                                        if(area.Position.Auto)
                                        {
                                                // Calculate area position
                                                areaPosition.Width = chartAreasRectangle.Width / areaColumns - elementSpacing;
                                                areaPosition.Height = chartAreasRectangle.Height / areaRows - elementSpacing;
                                                areaPosition.X = chartAreasRectangle.X + column * (chartAreasRectangle.Width / areaColumns) + elementSpacing; 
                                                areaPosition.Y = chartAreasRectangle.Y + row * (chartAreasRectangle.Height / areaRows) + elementSpacing; 

                                                // Calculate position of all titles in the collection docked outside of the chart area
                                                TitleCollection.CalcOutsideTitlePosition(this, chartGraph, area, ref areaPosition, elementSpacing);

                                                // Calculate position of the legend if it's docked outside of the chart area
                                                this.Legends.CalcOutsideLegendPosition(chartGraph, area, ref areaPosition, elementSpacing);

                                                // Set area position without changing the Auto flag
                                                area.Position.SetPositionNoAuto(areaPosition.X, areaPosition.Y, areaPosition.Width, areaPosition.Height);

                                                // Go to next area
                                                ++row;
                                                if(row >= areaRows)
                                                {
                                                        row = 0;
                                                        ++column;
                                                }
                                        }
                                        else
                                        {
                                                RectangleF rect = area.Position.ToRectangleF();

                                                // Calculate position of all titles in the collection docked outside of the chart area
                                                TitleCollection.CalcOutsideTitlePosition(this, chartGraph, area, ref rect, elementSpacing);

                                                // Calculate position of the legend if it's docked outside of the chart area
                                                this.Legends.CalcOutsideLegendPosition(chartGraph, area, ref rect, elementSpacing);
                                        }
                                }
                        }

                        //******************************************************
                        //** Align chart areas Position if required
                        //******************************************************
                        AlignChartAreasPosition();

                        //********************************************************
                        //** Check if only chart area position must be calculated.
                        //********************************************************
                        if(!calcAreaPositionOnly)
                        {

                                //******************************************************
                                //** Call Resize function for each chart area.
                                //******************************************************
                                foreach (ChartArea area in _chartAreas )
                                {

                                        // Check if area is visible
                                        if(area.Visible)

                                        {
                                                area.Resize(chartGraph);
                                        }
                                }

                                //******************************************************
                                //** Align chart areas InnerPlotPosition if required
                                //******************************************************
                                AlignChartAreas(AreaAlignmentStyles.PlotPosition);

                                //******************************************************
                                //** Calculate position of the legend if it's inside
                                //** chart plotting area
                                //******************************************************

                                // Calculate position of all titles in the collection docked outside of the chart area
                                TitleCollection.CalcInsideTitlePosition(this, chartGraph, elementSpacing);
                                
                                this.Legends.CalcInsideLegendPosition(chartGraph, elementSpacing);
                        }
                }

                /// <summary>
                /// Minimum and maximum do not have to be calculated 
                /// from data series every time. It is very time 
                /// consuming. Minimum and maximum are buffered 
                /// and only when this flags are set Minimum and 
                /// Maximum are refreshed from data.
                /// </summary>
                internal void ResetMinMaxFromData()
                {
            if (_chartAreas != null)
            {
                // Call ResetMinMaxFromData function for each chart area.
                foreach (ChartArea area in _chartAreas)
                {

                    // Check if area is visible
                    if (area.Visible)
                    {
                        area.ResetMinMaxFromData();
                    }
                }
            }
                }

                /// <summary>
                /// RecalculateAxesScale the chart picture.
                /// </summary>
                public void Recalculate()
                {
                        // Call ReCalc function for each chart area.
                        foreach (ChartArea area in _chartAreas )
                        {

                                // Check if area is visible
                                if(area.Visible)

                                {
                                        area.ReCalcInternal();
                                }
                        }
                }
        
                #endregion
                
                #region Chart picture properties

        // VSTS 96787-Text Direction (RTL/LTR)  
#if !Microsoft_CONTROL
        private RightToLeft rightToLeft = RightToLeft.No;
#endif //!Microsoft_CONTROL
        /// <summary>
        /// Gets or sets the RightToLeft type.
        /// </summary>
        [
        DefaultValue(RightToLeft.No)
        ]
        public RightToLeft RightToLeft
        {
            get
            {
#if Microsoft_CONTROL
                return this.Common.Chart.RightToLeft;
#else // !WIN_CONTROL
                return this.rightToLeft;
#endif // WIN_CONTROL
            }
            set
            {
#if Microsoft_CONTROL
                this.Common.Chart.RightToLeft = value;
#else // !Microsoft_CONTROL
                this.rightToLeft = value;
#endif // Microsoft_CONTROL
            }
        }

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

                /// <summary>
                /// Chart border skin style.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(BorderSkinStyle.None),
                SRDescription("DescriptionAttributeBorderSkin"),
#if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.InnerProperty),
#endif
                ]
                public BorderSkin BorderSkin
                {
                        get
                        {
                                return _borderSkin;
                        }
                        set
                        {
                                _borderSkin = value;
                        }
                }

#if ! Microsoft_CONTROL

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

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

                /// <summary>
                /// Reference to chart area collection
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                SRDescription("DescriptionAttributeChartAreas"),
#if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.InnerProperty),
#endif
        Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
                ]
                public ChartAreaCollection ChartAreas
                {
                        get
                        {
                                return _chartAreas;
                        }
                }

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

                /// <summary>
                /// Chart title collection.
                /// </summary>
                [
                SRCategory("CategoryAttributeCharttitle"),
                SRDescription("DescriptionAttributeTitles"),
        Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base),
#if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
                ]
                public TitleCollection Titles
                {
                        get
                        {
                                return _titles;
                        }
                }



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



                /// <summary>
                /// Background color for the Chart
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "White"),
        SRDescription("DescriptionAttributeBackColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public Color BackColor
                {
                        get
                        {
                                return _backColor;
                        }
                        set
                        {
#if !Microsoft_CONTROL
                        if(value == Color.Empty  || value.A != 255 || value == Color.Transparent)
                        {
                                // NOTE: Transparent colors are valid
                        }
#endif
                _backColor = value;
                        }
                }

                /// <summary>
                /// Border color for the Chart
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "White"),
                SRDescription("DescriptionAttributeBorderColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public Color BorderColor
                {
                        get
                        {
                return _borderColor;
                        }
                        set
                        {
                _borderColor = value;
                        }
                }

                /// <summary>
                /// Chart width
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(300),
                SRDescription("DescriptionAttributeWidth"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public int Width
                {
                        get
                        {
                return _width;
                        }
                        set
                        {
                this.InspectChartDimensions(value, this.Height);
                _width = value;
                Common.Width = _width;
                        }
                }

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




                /// <summary>
                /// Chart height
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(300),
                SRDescription("DescriptionAttributeHeight3"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public int Height
                {
                        get
                        {
                return _height;
                        }
                        set
                        {
                this.InspectChartDimensions(this.Width, value);
                _height = value;
                                Common.Height = value;
                        }
                }

                /// <summary>
                /// Back Hatch style
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(ChartHatchStyle.None),
        SRDescription("DescriptionAttributeBackHatchStyle"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute),
        #endif
        Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
                ]
                public ChartHatchStyle BackHatchStyle
                {
                        get
                        {
                return _backHatchStyle;
                        }
                        set
                        {
                _backHatchStyle = value;
                        }
                }

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

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

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

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

                /// <summary>
                /// Indicates that smoothing is applied while drawing shadows.
                /// </summary>
                [
                SRCategory("CategoryAttributeImage"),
                Bindable(true),
                DefaultValue(true),
                SRDescription("DescriptionAttributeSoftShadows3"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public bool IsSoftShadows
                {
                        get
                        {
                return _isSoftShadows;
                        }
                        set
                        {
                _isSoftShadows = value;
                        }
                }

                /// <summary>
                /// Specifies whether smoothing (antialiasing) is applied while drawing chart.
                /// </summary>
                [
                SRCategory("CategoryAttributeImage"),
                Bindable(true),
                DefaultValue(typeof(AntiAliasingStyles), "All"),
                SRDescription("DescriptionAttributeAntiAlias"),
        #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public AntiAliasingStyles AntiAliasing
                {
                        get
                        {
                return _antiAliasing;
                        }
                        set
                        {
                _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 _textAntiAliasingQuality;
                        }
                        set
                        {
                _textAntiAliasingQuality = value;
                        }
                }

                /// <summary>
                /// A type for the background gradient
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(GradientStyle.None),
        SRDescription("DescriptionAttributeBackGradientStyle"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute),
        #endif
        Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
                ]
                public GradientStyle BackGradientStyle
                {
                        get
                        {
                                return _backGradientStyle;
                        }
                        set
                        {
                                _backGradientStyle = value;
                        }
                }

                /// <summary>
                /// The second color which is used for a gradient
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeBackSecondaryColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public Color BackSecondaryColor
                {
                        get
                        {
                return _backSecondaryColor;
                        }
                        set
                        {
#if !Microsoft_CONTROL
                        if(value != Color.Empty && (value.A != 255 || value == Color.Transparent))
                        {
                                throw (new ArgumentException( SR.ExceptionBackSecondaryColorIsTransparent));
                        }
#endif
                _backSecondaryColor = value;
                        }
                }

                /// <summary>
                /// The width of the border line
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(1),
                SRDescription("DescriptionAttributeChart_BorderlineWidth"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public int BorderWidth
                {
                        get
                        {
                return _borderWidth;
                        }
                        set
                        {
                                if(value < 0)
                                {
                                        throw(new ArgumentOutOfRangeException("value", SR.ExceptionChartBorderIsNegative));
                                }
                _borderWidth = value;
                        }
                }

                /// <summary>
                /// The style of the border line
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(ChartDashStyle.NotSet),
        SRDescription("DescriptionAttributeBorderDashStyle"),
        #if !Microsoft_CONTROL
        PersistenceMode(PersistenceMode.Attribute)
        #endif
                ]
                public ChartDashStyle BorderDashStyle
                {
                        get
                        {
                return _borderDashStyle;
                        }
                        set
                        {
                _borderDashStyle = value;
                        }
                }

        /// <summary>
        /// Gets the font cache.
        /// </summary>
        /// <value>The font cache.</value>
        internal FontCache FontCache 
        {
            get { return _fontCache; }
        }

                #endregion      

                #region Chart areas alignment methods

                /// <summary>
                /// Checks if any of the chart areas are aligned.
                /// Also checks if the chart ares name in AlignWithChartArea property is valid.
                /// </summary>
                /// <returns>True if at least one area requires alignment.</returns>
                private bool IsAreasAlignmentRequired()
                {
                        bool    alignmentRequired = false;

                        // Loop through all chart areas
                        foreach(ChartArea area in this.ChartAreas)
                        {

                                // Check if chart area is visible
                                if(area.Visible)

                                {
                                        // Check if area is aligned
                    if (area.AlignWithChartArea != Constants.NotSetValue)
                                        {
                                                alignmentRequired = true;

                                                // Check the chart area used for alignment
                        if (this._chartAreas.IndexOf(area.AlignWithChartArea)<0)
                        {
                            throw (new InvalidOperationException(SR.ExceptionChartAreaNameReferenceInvalid(area.Name, area.AlignWithChartArea)));
                        }
                                        }
                                }
                        }

                        return alignmentRequired;
                }

                /// <summary>
                /// Creates a list of the aligned chart areas.
                /// </summary>
                /// <param name="masterArea">Master chart area.</param>
                /// <param name="type">Alignment type.</param>
                /// <param name="orientation">Vertical or Horizontal orientation.</param>
                /// <returns>List of areas that area aligned to the master area.</returns>
                private ArrayList GetAlignedAreasGroup(ChartArea masterArea, AreaAlignmentStyles type, AreaAlignmentOrientations orientation)
                {
                        ArrayList       areaList = new ArrayList();

                        // Loop throught the chart areas and get the ones aligned with specified master area
                        foreach(ChartArea area in this.ChartAreas)
                        {

                                // Check if chart area is visible
                                if(area.Visible)

                                {
                                        if(area.Name != masterArea.Name && 
                                                area.AlignWithChartArea == masterArea.Name && 
                                                (area.AlignmentStyle & type) == type &&
                                                (area.AlignmentOrientation & orientation) == orientation )
                                        {
                                                // Add "slave" area into the list
                                                areaList.Add(area);
                                        }
                                }
                        }

                        // If list is not empty insert "master" area in the beginning
                        if(areaList.Count > 0)
                        {
                                areaList.Insert(0, masterArea);
                        }

                        return areaList;
                }

                /// <summary>
                /// Performs specified type of alignment for the chart areas.
                /// </summary>
                /// <param name="type">Alignment type required.</param>
                internal void AlignChartAreas(AreaAlignmentStyles type)
                {
                        // Check if alignment required
                        if(IsAreasAlignmentRequired())
                        {
                                // Loop through all chart areas
                                foreach(ChartArea area in this.ChartAreas)
                                {

                                        // Check if chart area is visible
                                        if(area.Visible)

                                        {
                                                // Get vertical areas alignment group using current area as a master
                                                ArrayList alignGroup = GetAlignedAreasGroup(
                                                        area, 
                                                        type, 
                                                        AreaAlignmentOrientations.Vertical);

                                                // Align each area in the group
                                                if(alignGroup.Count > 0)
                                                {
                                                        AlignChartAreasPlotPosition(alignGroup, AreaAlignmentOrientations.Vertical);
                                                }

                                                // Get horizontal areas alignment group using current area as a master
                                                alignGroup = GetAlignedAreasGroup(
                                                        area, 
                                                        type, 
                                                        AreaAlignmentOrientations.Horizontal);

                                                // Align each area in the group
                                                if(alignGroup.Count > 0)
                                                {
                                                        AlignChartAreasPlotPosition(alignGroup, AreaAlignmentOrientations.Horizontal);
                                                }
                                        }
                                }
                        }
                }

                /// <summary>
                /// Align inner plot position of the chart areas in the group.
                /// </summary>
                /// <param name="areasGroup">List of areas in the group.</param>
                /// <param name="orientation">Group orientation.</param>
                private void AlignChartAreasPlotPosition(ArrayList areasGroup, AreaAlignmentOrientations orientation)
                {
                        //****************************************************************
                        //** Find the smalles size of the inner plot 
                        //****************************************************************
                        RectangleF      areaPlotPosition = ((ChartArea)areasGroup[0]).PlotAreaPosition.ToRectangleF();
                        foreach(ChartArea area in areasGroup)
                        {
                                if(area.PlotAreaPosition.X > areaPlotPosition.X)
                                {
                                        areaPlotPosition.X += area.PlotAreaPosition.X - areaPlotPosition.X;
                                        areaPlotPosition.Width -= area.PlotAreaPosition.X - areaPlotPosition.X;
                                }
                                if(area.PlotAreaPosition.Y > areaPlotPosition.Y)
                                {
                                        areaPlotPosition.Y += area.PlotAreaPosition.Y - areaPlotPosition.Y;
                                        areaPlotPosition.Height -= area.PlotAreaPosition.Y - areaPlotPosition.Y;
                                }
                                if(area.PlotAreaPosition.Right < areaPlotPosition.Right)
                                {
                                        areaPlotPosition.Width -= areaPlotPosition.Right - area.PlotAreaPosition.Right;
                                        if(areaPlotPosition.Width < 5)
                                        {
                                                areaPlotPosition.Width = 5;
                                        }
                                }
                                if(area.PlotAreaPosition.Bottom < areaPlotPosition.Bottom)
                                {
                                        areaPlotPosition.Height -= areaPlotPosition.Bottom - area.PlotAreaPosition.Bottom;
                                        if(areaPlotPosition.Height < 5)
                                        {
                                                areaPlotPosition.Height = 5;
                                        }
                                }
                        }

                        //****************************************************************
                        //** Align inner plot position for all areas
                        //****************************************************************
                        foreach(ChartArea area in areasGroup)
                        {
                                // Get curretn plot position of the area
                                RectangleF      rect = area.PlotAreaPosition.ToRectangleF();

                                // Adjust area position
                                if( (orientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
                                {
                                        rect.X = areaPlotPosition.X;
                                        rect.Width = areaPlotPosition.Width;
                                }
                                if( (orientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
                                {
                                        rect.Y = areaPlotPosition.Y;
                                        rect.Height = areaPlotPosition.Height;
                                }

                                // Set new plot position in coordinates relative to chart picture
                                area.PlotAreaPosition.SetPositionNoAuto(rect.X, rect.Y, rect.Width, rect.Height);

                                // Set new plot position in coordinates relative to chart area position
                                rect.X = (rect.X - area.Position.X) / area.Position.Width * 100f;
                                rect.Y = (rect.Y - area.Position.Y) / area.Position.Height * 100f;
                                rect.Width = rect.Width / area.Position.Width * 100f;
                                rect.Height = rect.Height / area.Position.Height * 100f;
                                area.InnerPlotPosition.SetPositionNoAuto(rect.X, rect.Y, rect.Width, rect.Height);

                                if( (orientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
                                {
                                        area.AxisX2.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
                                        area.AxisX.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
                                }
                                if( (orientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
                                {
                                        area.AxisY2.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
                                        area.AxisY.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
                                }
                        }

                }

                /// <summary>
                /// Aligns positions of the chart areas.
                /// </summary>
                private void AlignChartAreasPosition()
                {
                        // Check if alignment required
                        if(IsAreasAlignmentRequired())
                        {
                                // Loop through all chart areas
                                foreach(ChartArea area in this.ChartAreas)
                                {

                                        // Check if chart area is visible
                                        if(area.Visible)

                                        {
                                                // Check if area is alignd by Position to any other area
                        if (area.AlignWithChartArea != Constants.NotSetValue && (area.AlignmentStyle & AreaAlignmentStyles.Position) == AreaAlignmentStyles.Position)
                                                {
                                                        // Get current area position
                                                        RectangleF      areaPosition = area.Position.ToRectangleF();

                                                        // Get master chart area
                                                        ChartArea       masterArea = this.ChartAreas[area.AlignWithChartArea];

                                                        // Vertical alignment
                                                        if((area.AlignmentOrientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
                                                        {
                                                                // Align area position
                                                                areaPosition.X = masterArea.Position.X;
                                                                areaPosition.Width = masterArea.Position.Width;
                                                        }

                                                        // Horizontal alignment
                                                        if((area.AlignmentOrientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
                                                        {
                                                                // Align area position
                                                                areaPosition.Y = masterArea.Position.Y;
                                                                areaPosition.Height = masterArea.Position.Height;
                                                        }

                                                        // Set new position
                                                        area.Position.SetPositionNoAuto(areaPosition.X, areaPosition.Y, areaPosition.Width, areaPosition.Height);
                                                }
                                        }
                                }
                        }
        }

#if Microsoft_CONTROL

        /// <summary>
                /// Align chart areas cursor.
                /// </summary>
                /// <param name="changedArea">Changed chart area.</param>
                /// <param name="orientation">Orientation of the changed cursor.</param>
                /// <param name="selectionChanged">AxisName of change cursor or selection.</param>
                internal void AlignChartAreasCursor(ChartArea changedArea, AreaAlignmentOrientations orientation, bool selectionChanged)
                {
                        // Check if alignment required
                        if(IsAreasAlignmentRequired())
                        {
                                // Loop through all chart areas
                                foreach(ChartArea area in this.ChartAreas)
                                {

                                // Check if chart area is visible
                                        if(area.Visible)

                                        {
                                                // Get vertical areas alignment group using current area as a master
                                                ArrayList alignGroup = GetAlignedAreasGroup(
                                                        area, 
                                                        AreaAlignmentStyles.Cursor, 
                                                        orientation);

                                                // Align each area in the group if it contains changed area
                                                if(alignGroup.Contains(changedArea))
                                                {
                                                        // Set cursor position for all areas in the group
                                                        foreach(ChartArea groupArea in alignGroup)
                                                        {
                                                                groupArea.alignmentInProcess = true;

                                                                if(orientation == AreaAlignmentOrientations.Vertical)
                                                                {
                                                                        if(selectionChanged)
                                                                        {
                                                                                groupArea.CursorX.SelectionStart = changedArea.CursorX.SelectionStart;
                                                                                groupArea.CursorX.SelectionEnd = changedArea.CursorX.SelectionEnd;
                                                                        }
                                                                        else
                                                                        {
                                                                                groupArea.CursorX.Position = changedArea.CursorX.Position;
                                                                        }
                                                                }
                                                                if(orientation == AreaAlignmentOrientations.Horizontal)
                                                                {
                                                                        if(selectionChanged)
                                                                        {
                                                                                groupArea.CursorY.SelectionStart = changedArea.CursorY.SelectionStart;
                                                                                groupArea.CursorY.SelectionEnd = changedArea.CursorY.SelectionEnd;
                                                                        }
                                                                        else
                                                                        {
                                                                                groupArea.CursorY.Position = changedArea.CursorY.Position;
                                                                        }
                                                                }

                                                                groupArea.alignmentInProcess = false;
                                                        }
                                                }
                                        }
                                }
                        }
        }

        /// <summary>
                /// One of the chart areas was zoomed by the user.
                /// </summary>
                /// <param name="changedArea">Changed chart area.</param>
                /// <param name="orientation">Orientation of the changed scaleView.</param>
                /// <param name="disposeBufferBitmap">Area double fuffer image must be disposed.</param>
                internal void AlignChartAreasZoomed(ChartArea changedArea, AreaAlignmentOrientations orientation, bool disposeBufferBitmap)
                {
                        // Check if alignment required
                        if(IsAreasAlignmentRequired())
                        {
                                // Loop through all chart areas
                                foreach(ChartArea area in this.ChartAreas)
                                {

                                // Check if chart area is visible
                                        if(area.Visible)

                                        {
                                                // Get vertical areas alignment group using current area as a master
                                                ArrayList alignGroup = GetAlignedAreasGroup(
                                                        area, 
                                                        AreaAlignmentStyles.AxesView, 
                                                        orientation);

                                                // Align each area in the group if it contains changed area
                                                if(alignGroup.Contains(changedArea))
                                                {
                                                        // Set cursor position for all areas in the group
                                                        foreach(ChartArea groupArea in alignGroup)
                                                        {
                                                                // Clear image buffer
                                                                if(groupArea.areaBufferBitmap != null && disposeBufferBitmap)
                                                                {
                                                                        groupArea.areaBufferBitmap.Dispose();
                                                                        groupArea.areaBufferBitmap = null;
                                                                }

                                                                if(orientation == AreaAlignmentOrientations.Vertical)
                                                                {
                                                                        groupArea.CursorX.SelectionStart = double.NaN;
                                                                        groupArea.CursorX.SelectionEnd = double.NaN;
                                                                }
                                                                if(orientation == AreaAlignmentOrientations.Horizontal)
                                                                {
                                                                        groupArea.CursorY.SelectionStart = double.NaN;
                                                                        groupArea.CursorY.SelectionEnd = double.NaN;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
        }

#endif //Microsoft_CONTROL

        /// <summary>
                /// Align chart areas axes views.
                /// </summary>
                /// <param name="changedArea">Changed chart area.</param>
                /// <param name="orientation">Orientation of the changed scaleView.</param>
                internal void AlignChartAreasAxesView(ChartArea changedArea, AreaAlignmentOrientations orientation)
                {
                        // Check if alignment required
                        if(IsAreasAlignmentRequired())
                        {
                                // Loop through all chart areas
                                foreach(ChartArea area in this.ChartAreas)
                                {

                                        // Check if chart area is visible
                                        if(area.Visible)

                                        {
                                                // Get vertical areas alignment group using current area as a master
                                                ArrayList alignGroup = GetAlignedAreasGroup(
                                                        area, 
                                                        AreaAlignmentStyles.AxesView, 
                                                        orientation);

                                                // Align each area in the group if it contains changed area
                                                if(alignGroup.Contains(changedArea))
                                                {
                                                        // Set cursor position for all areas in the group
                                                        foreach(ChartArea groupArea in alignGroup)
                                                        {
                                                                groupArea.alignmentInProcess = true;

                                                                if(orientation == AreaAlignmentOrientations.Vertical)
                                                                {
                                                                        groupArea.AxisX.ScaleView.Position = changedArea.AxisX.ScaleView.Position;
                                                                        groupArea.AxisX.ScaleView.Size = changedArea.AxisX.ScaleView.Size;
                                                                        groupArea.AxisX.ScaleView.SizeType = changedArea.AxisX.ScaleView.SizeType;

                                                                        groupArea.AxisX2.ScaleView.Position = changedArea.AxisX2.ScaleView.Position;
                                                                        groupArea.AxisX2.ScaleView.Size = changedArea.AxisX2.ScaleView.Size;
                                                                        groupArea.AxisX2.ScaleView.SizeType = changedArea.AxisX2.ScaleView.SizeType;
                                                                }
                                                                if(orientation == AreaAlignmentOrientations.Horizontal)
                                                                {
                                                                        groupArea.AxisY.ScaleView.Position = changedArea.AxisY.ScaleView.Position;
                                                                        groupArea.AxisY.ScaleView.Size = changedArea.AxisY.ScaleView.Size;
                                                                        groupArea.AxisY.ScaleView.SizeType = changedArea.AxisY.ScaleView.SizeType;

                                                                        groupArea.AxisY2.ScaleView.Position = changedArea.AxisY2.ScaleView.Position;
                                                                        groupArea.AxisY2.ScaleView.Size = changedArea.AxisY2.ScaleView.Size;
                                                                        groupArea.AxisY2.ScaleView.SizeType = changedArea.AxisY2.ScaleView.SizeType;
                                                                }

                                                                groupArea.alignmentInProcess = false;
                                                        }
                                                }
                                        }
                                }
                        }
                }

                #endregion

                #region Helper methods

        /// <summary>
        /// Inspects the chart dimensions.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        internal void InspectChartDimensions(int width, int height)
        {
            if (this.Chart.IsDesignMode() && ((width * height) > (100 * 1024 *1024)))
            {
                throw new ArgumentException(SR.ExceptionChartOutOfLimits);
            }
            if (width < 0)
            {
                throw new ArgumentException(SR.ExceptionValueMustBeGreaterThan("Width", "0px"));
            }
            if (height < 0)
            {
                throw new ArgumentException(SR.ExceptionValueMustBeGreaterThan("Height", "0px"));
            }
        }

                /// <summary>
                /// Loads chart appearance template from file.
                /// </summary>
                /// <param name="name">Template file name to load from.</param>
                public void LoadTemplate(string name)
                {
            // Check arguments
            if (name == null)
                throw new ArgumentNullException("name");

                        // Load template data into the stream
#if Microsoft_CONTROL
                        Stream  stream = new FileStream(name, FileMode.Open, FileAccess.Read);
#else   // Microsoft_CONTROL
                        Stream  stream = LoadTemplateData(name);
#endif  // Microsoft_CONTROL

                        // Load template from stream
                        LoadTemplate(stream);

                        // Close tempate stream
                        stream.Close();
                }

                /// <summary>
                /// Loads chart appearance template from stream.
                /// </summary>
                /// <param name="stream">Template stream to load from.</param>
        public void LoadTemplate(Stream stream)
        {
            // Check arguments
            if (stream == null)
                throw new ArgumentNullException("stream");

            ChartSerializer serializer = (ChartSerializer)this.Common.container.GetService(typeof(ChartSerializer));
            if (serializer != null)
            {
                // Save previous serializer properties
                string oldSerializableContent = serializer.SerializableContent;
                string oldNonSerializableContent = serializer.NonSerializableContent;
                SerializationFormat oldFormat = serializer.Format;
                bool oldIgnoreUnknownXmlAttributes = serializer.IsUnknownAttributeIgnored;
                bool oldTemplateMode = serializer.IsTemplateMode;

                // Set serializer properties
                serializer.Content = SerializationContents.Appearance;
                serializer.SerializableContent += ",Chart.Titles,Chart.Annotations," +
                                                  "Chart.Legends,Legend.CellColumns,Legend.CustomItems,LegendItem.Cells," +
                                                  "Chart.Series,Series.*Style," +
                                                  "Chart.ChartAreas,ChartArea.Axis*," +
                                                  "Axis.*Grid,Axis.*TickMark, Axis.*Style," +
                                                  "Axis.StripLines, Axis.CustomLabels";
                serializer.Format = SerializationFormat.Xml;
                serializer.IsUnknownAttributeIgnored = true;
                serializer.IsTemplateMode = true;

                try
                {
                    // Load template
                    serializer.Load(stream);
                }
                catch (Exception ex)
                {
                    throw (new InvalidOperationException(ex.Message));
                }
                finally
                {
                    // Restore previous serializer properties
                    serializer.SerializableContent = oldSerializableContent;
                    serializer.NonSerializableContent = oldNonSerializableContent;
                    serializer.Format = oldFormat;
                    serializer.IsUnknownAttributeIgnored = oldIgnoreUnknownXmlAttributes;
                    serializer.IsTemplateMode = oldTemplateMode;
                }
            }
        }

#if !Microsoft_CONTROL

                /// <summary>
                /// Loads template data from the URL.
                /// </summary>
                /// <param name="url">Template URL.</param>
                /// <returns>Stream with template data or null if error.</returns>
                private Stream LoadTemplateData(string url)
                {
            Debug.Assert(url != null, "LoadTemplateData: handed a null url string");

                        Stream  dataStream = null;

                        // Try to load as relative URL using the Control object
                        if(dataStream == null)
                        {
                if (this.Common != null && 
                    this.Common.Chart != null &&
                    this.Common.Chart.Page != null)
                {
                    try
                    {
                        dataStream = new FileStream(
                            this.Common.Chart.Page.MapPath(url),
                            FileMode.Open);
                    }
                    catch (NotSupportedException)
                    {
                        dataStream = null;
                    }
                    catch (SecurityException)
                    {
                        dataStream = null;
                    }
                    catch (FileNotFoundException)
                    {
                        dataStream = null;
                    }
                    catch (DirectoryNotFoundException)
                    {
                        dataStream = null;
                    }
                    catch (PathTooLongException)
                    {
                        dataStream = null;
                    }
                }
                        }

                        // Try to load image using the Web Request
                        if(dataStream == null)
                        {
                                Uri     templateUri = null;
                try
                {
                    // Try to create URI directly from template URL (will work in case of absolute URL)
                    templateUri = new Uri(url);
                }
                catch (UriFormatException)
                {
                    templateUri = null;
                }

                                // Make absolute URL using web form document URL
                                if(templateUri == null)
                                {
                    if (this.Common != null && this.Common.Chart != null)
                                        {
                                                string  webFormUrl = this.Common.Chart.webFormDocumentURL;
                                                int slashIndex = webFormUrl.LastIndexOf('/');
                                                if(slashIndex != -1)
                                                {
                                                        webFormUrl = webFormUrl.Substring(0, slashIndex + 1);
                                                }

                        try
                        {
                            templateUri = new Uri(new Uri(webFormUrl), url);
                        }
                        catch (UriFormatException)
                        {
                            templateUri = null;
                        }
                                        }
                                }

                                // Load image from file or web resource
                                if(templateUri != null)
                                {
                    try
                    {
                        WebRequest request = WebRequest.Create(templateUri);
                        dataStream = request.GetResponse().GetResponseStream();
                    }
                    catch (NotSupportedException)
                    {
                        dataStream = null;
                    }
                    catch (NotImplementedException)
                    {
                        dataStream = null;
                    }
                    catch (SecurityException)
                    {
                        dataStream = null;
                    }
                                }
                        }

                        // Try to load as file
                        if(dataStream == null)
                        {
                dataStream = new FileStream(url, FileMode.Open);
                        }

                        return dataStream;
                }

#endif  // Microsoft_CONTROL



#if !Microsoft_CONTROL


        /// <summary>
        /// Writes chart map tag into the stream.
        /// </summary>
        /// <param name="output">Html writer to output the data to.</param>
        /// <param name="mapName">Chart map name.</param>
        internal void WriteChartMapTag(HtmlTextWriter output, string mapName)
                {
            output.WriteLine();
            output.AddAttribute(HtmlTextWriterAttribute.Name, mapName);
            output.AddAttribute(HtmlTextWriterAttribute.Id, mapName);
            output.RenderBeginTag(HtmlTextWriterTag.Map);

                        //****************************************************
                        //** Fire map areas customize event
                        //****************************************************

                        // Make sure only non-custom items are passed into the event handler
                        MapAreasCollection      custCollection = new MapAreasCollection();

                        // Move all non-custom items
            for (int index = 0; index < _mapAreas.Count; index++)
                        {
                if (!_mapAreas[index].IsCustom)
                                {
                    custCollection.Add(_mapAreas[index]);
                    _mapAreas.RemoveAt(index);
                                        --index;
                                }
                        }

                        // Call a notification event, so that area items collection can be modified by user
            Common.Chart.CallOnCustomizeMapAreas(custCollection);

                        // Add customized items
                        foreach(MapArea area in custCollection)
                        {
                                area.IsCustom = false;
                _mapAreas.Add(area);
                        }

                        //****************************************************
                        //** Add all map areas
                        //****************************************************
            foreach (MapArea area in _mapAreas)
                        {
                area.RenderTag(output, this.Common.Chart);
                        }
            // if this procedure is enforced to run the image maps have to have at least one map area. 
            if (_mapAreas.Count == 0)
            {
                output.Write("<area shape=\"rect\" coords=\"0,0,0,0\" alt=\"\" />");
            }
                        
            //****************************************************
                        //** End of the map
                        //****************************************************
            output.RenderEndTag();
            
                        return;
                }

#endif

                /// <summary>
                /// Returns the default title from Titles collection.
                /// </summary>
                /// <param name="create">Create title if it doesn't exists.</param>
                /// <returns>Default title.</returns>
                internal Title GetDefaultTitle(bool create)
                {
                        // Check if default title exists
                        Title   defaultTitle = null;
                        foreach(Title title in this.Titles)
                        {
                                if(title.Name == "Default Title")
                                {
                                        defaultTitle = title;
                                }
                        }

                        // Create new default title
                        if(defaultTitle == null && create)
                        {
                                defaultTitle = new Title();
                                defaultTitle.Name = "Default Title";
                                this.Titles.Insert(0, defaultTitle);
                        }

                        return defaultTitle;
                }

                /// <summary>
                /// Checks if tooltips are enabled
                /// </summary>
                /// <returns>true if tooltips enabled</returns>
                private bool IsToolTipsEnabled()
                {
                        
                        // Data series loop
                        foreach( Series series in Common.DataManager.Series )
                        {
                                // Check series tooltips
                                if( series.ToolTip.Length > 0)
                                {
                                        // ToolTips enabled
                                        return true;
                                }

                                // Check series tooltips
                                if( series.LegendToolTip.Length > 0 ||
                                        series.LabelToolTip.Length > 0)
                                {
                                        // ToolTips enabled
                                        return true;
                                }

                                // Check point tooltips only for "non-Fast" chart types
                                if( !series.IsFastChartType() )
                                {
                                        // Data point loop
                                        foreach( DataPoint point in series.Points )
                                        {
                                                // ToolTip empty
                                                if( point.ToolTip.Length > 0)
                                                {
                                                        // ToolTips enabled
                                                        return true;
                                                }
                                                // ToolTip empty
                                                if( point.LegendToolTip.Length > 0 ||
                                                        point.LabelToolTip.Length > 0)
                                                {
                                                        // ToolTips enabled
                                                        return true;
                                                }
                                        }
                                }
                        }

                        // Legend items loop
                        foreach( Legend legend in Legends )
                        {
                                foreach( LegendItem legendItem in legend.CustomItems )
                                {
                                        // ToolTip empty
                                        if( legendItem.ToolTip.Length > 0 )
                                        {
                                                return true;
                                        }
                                }
                        }

                        // Title items loop
                        foreach( Title title in Titles )
                        {
                                // ToolTip empty
                                if( title.ToolTip.Length > 0 )
                                {
                                        return true;
                                }
                        }

                        return false;
                }

                #endregion

        #region IDisposable Members
        /// <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 override void Dispose(bool disposing)
        {
            if (disposing)
            {   
                // Dispose managed resources
                if (ChartGraph != null)
                {
                    ChartGraph.Dispose();
                    ChartGraph = null;
                }
                if (_legends != null)
                {
                    _legends.Dispose();
                    _legends = null;
                }
                if (_titles != null)
                {
                    _titles.Dispose();
                    _titles = null;
                }
                if (_chartAreas != null)
                {
                    _chartAreas.Dispose();
                    _chartAreas = null;
                }
                if (_annotations != null)
                {
                    _annotations.Dispose();
                    _annotations = null;
                }
                if (hotRegionsList != null)
                {
                    hotRegionsList.Dispose();
                    hotRegionsList = null;
                }
                if (_fontCache != null)
                {
                    _fontCache.Dispose();
                    _fontCache = null;
                }
                if (_borderSkin != null)
                {
                    _borderSkin.Dispose();
                    _borderSkin = null;
                }
#if ! Microsoft_CONTROL
                if (_mapAreas != null)
                {
                    _mapAreas.Dispose();
                    _mapAreas = null;
                }
#endif

#if Microsoft_CONTROL
                if (nonTopLevelChartBuffer != null)
                {
                    nonTopLevelChartBuffer.Dispose();
                    nonTopLevelChartBuffer = null;
                }
#endif
            }
            base.Dispose(disposing);
        }

        #endregion
    }

        /// <summary>
        /// Event arguments of Chart paint event.
        /// </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 ChartPaintEventArgs : EventArgs
        {
                #region Fields

                // Private fields
        private object          _chartElement = null;
        private ChartGraphics   _chartGraph = null;
                private CommonElements  _common = null;
                private Chart                   _chart = null;
                private ElementPosition _position = null;

                #endregion

                #region Properties


        /// <summary>
        /// Gets the chart element of the event.
        /// </summary>
        /// <value>The chart element.</value>
        public object ChartElement
        {
            get
            {
                return _chartElement;
            }
        } 


                /// <summary>
                /// Gets the ChartGraphics object of the event.
                /// </summary>
                public ChartGraphics ChartGraphics
                {
                        get
                        {
                                return _chartGraph;
                        }
                } 

                /// <summary>
                /// Chart Common elements.
                /// </summary>
                internal CommonElements CommonElements
                {
                        get
                        {
                                return _common;
                        }
                } 

                /// <summary>
                /// Chart element position in relative coordinates of the event.
                /// </summary>
                public ElementPosition Position
                {
                        get
                        {
                return _position;
                        }
                } 

                /// <summary>
                /// Chart object of the event.
                /// </summary>
            public  Chart Chart
                {
                        get
                        {
                if (_chart == null && _common != null)
                                {
                    _chart = _common.Chart;
                                }

                return _chart;
                        }
                } 

                #endregion

                #region Methods

                /// <summary>
                /// Default constructor is not accessible
                /// </summary>
                private ChartPaintEventArgs()
                {
                }

        /// <summary>
        /// Paint event arguments constructor.
        /// </summary>
        /// <param name="chartElement">Chart element.</param>
        /// <param name="chartGraph">Chart graphics.</param>
        /// <param name="common">Common elements.</param>
        /// <param name="position">Position.</param>
        internal ChartPaintEventArgs(object chartElement, ChartGraphics chartGraph, CommonElements common, ElementPosition position)
                {
            this._chartElement = chartElement;
            this._chartGraph = chartGraph;
            this._common = common;
            this._position = position;
                }

                #endregion
        }

    /// <summary>
    /// Event arguments of localized numbers formatting event.
    /// </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 FormatNumberEventArgs : EventArgs
    {
        #region Fields

        // Private fields
        private double _value;
        private string _format;
        private string _localizedValue;
        private ChartValueType _valueType = ChartValueType.Auto;
        private object _senderTag;
        private ChartElementType _elementType = ChartElementType.Nothing;

        #endregion

        #region Properties

        /// <summary>
        /// Value to be formatted.
        /// </summary>
        public double Value
        {
            get { return this._value; }
        }

        /// <summary>
        /// Localized text.
        /// </summary>
        public string LocalizedValue
        {
            get { return _localizedValue; }
            set { _localizedValue = value; }
        }

        /// <summary>
        /// Format string.
        /// </summary>
        public string Format
        {
            get { return _format; }
        }

        /// <summary>
        /// Value type.
        /// </summary>
        public ChartValueType ValueType
        {
            get { return _valueType; }
        }

        /// <summary>
        /// The sender object of the event.
        /// </summary>
        public object SenderTag
        {
            get { return _senderTag; }
        }

        /// <summary>
        /// Chart element type.
        /// </summary>
        public ChartElementType ElementType
        {
            get { return _elementType; }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Default constructor is not accessible
        /// </summary>
        private FormatNumberEventArgs()
        {
        }

        /// <summary>
        /// Object constructor.
        /// </summary>
        /// <param name="value">Value to be formatted.</param>
        /// <param name="format">Format string.</param>
        /// <param name="valueType">Value type..</param>
        /// <param name="localizedValue">Localized value.</param>
        /// <param name="senderTag">Chart element object tag.</param>
        /// <param name="elementType">Chart element type.</param>
        internal FormatNumberEventArgs(double value, string format, ChartValueType valueType, string localizedValue, object senderTag, ChartElementType elementType)
        {
            this._value = value;
            this._format = format;
            this._valueType = valueType;
            this._localizedValue = localizedValue;
            this._senderTag = senderTag;
            this._elementType = elementType;
        }

        #endregion
    }

    #region FontCache
    /// <summary>
    /// Font cache class helps ChartElements to reuse the Font instances
    /// </summary>
    internal class FontCache : IDisposable
    {
        #region Static

        // Default font family name
        private static string _defaultFamilyName;

        /// <summary>
        /// Gets the default font family name.
        /// </summary>
        /// <value>The default font family name.</value>
        public static string DefaultFamilyName
        {
            get
            {
                if (_defaultFamilyName == null)
                {
                    // Find the "Microsoft Sans Serif" font
                    foreach (FontFamily fontFamily in FontFamily.Families)
                    {
                        if (fontFamily.Name == "Microsoft Sans Serif")
                        {
                            _defaultFamilyName = fontFamily.Name;
                            break;
                        }
                    }
                    // Not found - use the default Sans Serif font
                    if (_defaultFamilyName == null)
                    {
                        _defaultFamilyName = FontFamily.GenericSansSerif.Name;
                    }
                }
                return _defaultFamilyName;
            }
        }
        #endregion

        #region Fields

        // Cached fonts dictionary 
        private Dictionary<KeyInfo, Font> _fontCache = new Dictionary<KeyInfo, Font>(new KeyInfo.EqualityComparer());

        #endregion // Fields

        #region Properties
        /// <summary>
        /// Gets the default font.
        /// </summary>
        /// <value>The default font.</value>
        public Font DefaultFont 
        { 
            get { return this.GetFont(DefaultFamilyName, 8);  }
        }

        /// <summary>
        /// Gets the default font.
        /// </summary>
        /// <value>The default font.</value>
        public Font DefaultBoldFont
        {
            get { return this.GetFont(DefaultFamilyName, 8, FontStyle.Bold); }
        }
        #endregion

        #region Methods

        /// <summary>
        /// Gets the font.
        /// </summary>
        /// <param name="familyName">Name of the family.</param>
        /// <param name="size">The size.</param>
        /// <returns>Font instance</returns>
        public Font GetFont(string familyName, int size)
        {
            KeyInfo key = new KeyInfo(familyName, size);
            if (!this._fontCache.ContainsKey(key))
            {
                this._fontCache.Add(key, new Font(familyName, size));
            }
            return this._fontCache[key];
        }

        /// <summary>
        /// Gets the font.
        /// </summary>
        /// <param name="familyName">Name of the family.</param>
        /// <param name="size">The size.</param>
        /// <param name="style">The style.</param>
        /// <returns>Font instance</returns>
        public Font GetFont(string familyName, float size, FontStyle style)
        {
            KeyInfo key = new KeyInfo(familyName, size, style);
            if (!this._fontCache.ContainsKey(key))
            {
                this._fontCache.Add(key, new Font(familyName, size, style));
            }
            return this._fontCache[key];
        }

        /// <summary>
        /// Gets the font.
        /// </summary>
        /// <param name="family">The family.</param>
        /// <param name="size">The size.</param>
        /// <param name="style">The style.</param>
        /// <returns>Font instance</returns>
        public Font GetFont(FontFamily family, float size, FontStyle style)
        {
            KeyInfo key = new KeyInfo(family, size, style);
            if (!this._fontCache.ContainsKey(key))
            {
                this._fontCache.Add(key, new Font(family, size, style));
            }
            return this._fontCache[key];
        }

        /// <summary>
        /// Gets the font.
        /// </summary>
        /// <param name="family">The family.</param>
        /// <param name="size">The size.</param>
        /// <param name="style">The style.</param>
        /// <param name="unit">The unit.</param>
        /// <returns>Font instance</returns>
        public Font GetFont(FontFamily family, float size, FontStyle style, GraphicsUnit unit)
        {
            KeyInfo key = new KeyInfo(family, size, style, unit);
            if (!this._fontCache.ContainsKey(key))
            {
                this._fontCache.Add(key, new Font(family, size, style, unit));
            }
            return this._fontCache[key];
        }

        #endregion

        #region IDisposable Members

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            foreach (Font font in _fontCache.Values)
            {
                font.Dispose();
            }
            _fontCache.Clear();
            GC.SuppressFinalize(this);
        }

        #endregion

        #region FontKeyInfo struct
        /// <summary>
        /// Font key info
        /// </summary>
        private class KeyInfo 
        { 
            string          _familyName;
            float           _size = 8;
            GraphicsUnit    _unit = GraphicsUnit.Point;
            FontStyle       _style = FontStyle.Regular;
            int             _gdiCharSet = 1;

            /// <summary>
            /// Initializes a new instance of the <see cref="KeyInfo"/> class.
            /// </summary>
            /// <param name="familyName">Name of the family.</param>
            /// <param name="size">The size.</param>
            public KeyInfo(string familyName, float size)
            {
                this._familyName = familyName;
                this._size = size;
            }
            /// <summary>
            /// Initializes a new instance of the <see cref="KeyInfo"/> class.
            /// </summary>
            /// <param name="familyName">Name of the family.</param>
            /// <param name="size">The size.</param>
            /// <param name="style">The style.</param>
            public KeyInfo(string familyName, float size, FontStyle style)
            {
                this._familyName = familyName;
                this._size = size;
                this._style = style;
            }
            /// <summary>
            /// Initializes a new instance of the <see cref="KeyInfo"/> class.
            /// </summary>
            /// <param name="family">The family.</param>
            /// <param name="size">The size.</param>
            /// <param name="style">The style.</param>
            public KeyInfo(FontFamily family, float size, FontStyle style)
            {
                this._familyName = family.ToString();
                this._size = size;
                this._style = style;
            }
            /// <summary>
            /// Initializes a new instance of the <see cref="KeyInfo"/> class.
            /// </summary>
            /// <param name="family">The family.</param>
            /// <param name="size">The size.</param>
            /// <param name="style">The style.</param>
            /// <param name="unit">The unit.</param>
            public KeyInfo(FontFamily family, float size, FontStyle style, GraphicsUnit unit)
            {
                this._familyName = family.ToString();
                this._size = size;
                this._style = style;
                this._unit = unit;
            }

            #region IEquatable<FontKeyInfo> Members
            /// <summary>
            /// KeyInfo equality comparer
            /// </summary>
            internal class EqualityComparer : IEqualityComparer<KeyInfo> 
            {
                /// <summary>
                /// Determines whether the specified objects are equal.
                /// </summary>
                /// <param name="x">The first object of type <paramref name="x"/> to compare.</param>
                /// <param name="y">The second object of type <paramref name="y"/> to compare.</param>
                /// <returns>
                /// true if the specified objects are equal; otherwise, false.
                /// </returns>
                public bool Equals(KeyInfo x, KeyInfo y)
                {
                    return
                        x._size == y._size &&
                        x._familyName == y._familyName &&
                        x._unit == y._unit &&
                        x._style == y._style &&
                        x._gdiCharSet == y._gdiCharSet;
                }

                /// <summary>
                /// Returns a hash code for the specified object.
                /// </summary>
                /// <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.</param>
                /// <returns>A hash code for the specified object.</returns>
                /// <exception cref="T:System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.</exception>
                public int GetHashCode(KeyInfo obj)
                {
                    return obj._familyName.GetHashCode() ^ obj._size.GetHashCode();
                }
            }
            #endregion
        }
        #endregion
    }
    #endregion


}