Updates referencesource to .NET 4.7

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

//-------------------------------------------------------------
// <copyright company=\92Microsoft Corporation\92>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:               Legend.cs
//
//  Namespace:  DataVisualization.Charting
//
//      Classes:        Legend, LegendCollection, LegendItemsCollection, 
//              LegendItem
//
//  Purpose:    Chart Legend consist of default and custom legend 
//              items. Default items are automatically added based
//              on the data series and custom items are added by
//              the user. Each item usually consist of 2 cells; 
//              series color marker and series name. Legend item 
//              cells form vertical columns in the legend.
//  
//              Please refer to the Chart documentation which 
//              contains images and samples describing legend features.
//
//  NOTE: In early versions of the Chart control only 1 legend was 
//  exposed through the Legend property of the root chart object. 
//  Due to the customer requests, support for unlimited number of 
//  legends was added through the LegendCollection exposed as a 
//  Legends property in the root chart object. Old propertys was 
//  deprecated and marked as non-browsable. 
//
//      Reviewed:       AG - Jul 31, 2002; 
//              GS - Aug 7, 2002
//              AG - Microsoft 14, 2007
//
//===================================================================

#region Used namespaces

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;

#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;
        using System.ComponentModel.Design.Serialization;
        using System.Reflection;
        using System.Windows.Forms.Design;
#else
        using System.Web;
        using System.Web.UI;
        using System.Web.UI.DataVisualization.Charting;
        using System.Web.UI.DataVisualization.Charting.Data;
        using System.Web.UI.DataVisualization.Charting.Utilities;
        using System.Web.UI.DataVisualization.Charting.ChartTypes;
#endif


#endregion

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

#endif
{
        #region Legend enumerations

    /// <summary>
    /// An enumeration of legend item orderings.
    /// </summary>
    public enum LegendItemOrder
    {
        /// <summary>
        /// Items will be added into the legend in an order automatically determined by the chart.
        /// </summary>
        Auto,

        /// <summary>
        /// Items will be added into the legend in the same order as the chart series.
        /// </summary>
        SameAsSeriesOrder,

        /// <summary>
        /// Items will be added into the legend in the same order as the chart series.
        /// </summary>
        ReversedSeriesOrder

    };

        /// <summary>
        /// An enumeration of legend separator styles.
        /// </summary>
        public enum LegendSeparatorStyle
        {
                /// <summary>
                /// No separator will be shown.
                /// </summary>
                None,

        /// <summary>
        /// Single solid line separator.
        /// </summary>
                Line,

        /// <summary>
        /// Single solid thick line separator.
        /// </summary>
                ThickLine,

                /// <summary>
                /// Double solid line separator.
                /// </summary>
                DoubleLine,

                /// <summary>
                /// Single dash line separator.
                /// </summary>
                DashLine,

                /// <summary>
                /// Single dot line separator.
                /// </summary>
                DotLine,

                /// <summary>
                /// Gradient solid line separator.
                /// </summary>
                GradientLine,

                /// <summary>
                /// Thick gradient solid line separator.
                /// </summary>
                ThickGradientLine,
        }



        /// <summary>
    /// An enumeration that specifies a style for a legend item's symbol.
        /// </summary>
        public enum LegendImageStyle
        {
                /// <summary>
        /// The symbol will be a rectangle.
                /// </summary>
                Rectangle, 

                /// <summary>
        /// The symbol will be a line.
                /// </summary>
                Line, 

                /// <summary>
        /// The symbol will be a marker.
                /// </summary>
                Marker
        }

        /// <summary>
        /// An enumeration of legend styles.
        /// </summary>
        public enum LegendStyle
        {
                /// <summary>
                /// One column, many rows.
                /// </summary>
                Column, 

                /// <summary>
                /// One row, many columns.
                /// </summary>
                Row, 

                /// <summary>
                /// Many column, many rows.
                /// </summary>
                Table
        };

        /// <summary>
        /// An enumeration of legend table styles.
        /// </summary>
        public enum LegendTableStyle
        {
                /// <summary>
        /// The legend table style is automatically determined by the chart.
                /// </summary>
                Auto, 

                /// <summary>
        /// The legend items will be fit horizontally within the legend.  
        /// It is preferred to use this style when the docking is set to top or bottom.
                /// </summary>
                Wide, 

                /// <summary>
        /// The legend items will be fit vertically within the legend.  
        /// It is preferred to use this style when docking is set to left or right.
                /// </summary>
                Tall
        };
        
        #endregion

    /// <summary>
    /// The legend class represents a single chart legend. It contains visual
    /// appearance, position and content properties. This class is also 
    /// responsible for drawing and positioning of the legend.
    /// </summary>
        [
        SRDescription("DescriptionAttributeLegend_Legend"),
        DefaultProperty("Enabled"),
        ]
#if ASPPERM_35
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class Legend : ChartNamedElement
        {
            #region Fields

        //***********************************************************
                //** Private data members, which store properties values
                //***********************************************************
                private ElementPosition                 _position = null;
                private bool                                    _enabled = true;

                private LegendStyle                             _legendStyle = LegendStyle.Table;

                private LegendTableStyle                _legendTableStyle = LegendTableStyle.Auto;
                private LegendItemsCollection   _customLegends = null;
                private ChartHatchStyle                 _backHatchStyle = ChartHatchStyle.None;
                private string                                  _backImage = "";
                private ChartImageWrapMode              _backImageWrapMode = ChartImageWrapMode.Tile;
                private Color                                   _backImageTransparentColor = Color.Empty;
                private ChartImageAlignmentStyle        _backImageAlignment = ChartImageAlignmentStyle.TopLeft;
                private GradientStyle                   _backGradientStyle = GradientStyle.None;
                private Color                                   _backSecondaryColor = Color.Empty;
                private Color                                   _borderColor = Color.Empty;
                private Color                                   _backColor = Color.Empty;
                private int                                             _borderWidth = 1;
                private ChartDashStyle                  _borderDashStyle = ChartDashStyle.Solid;
        private FontCache               _fontCache = new FontCache();
        private Font                    _font = null;
                private Color                                   _foreColor = Color.Black;
                private StringAlignment                 _legendAlignment = StringAlignment.Near;
                private Docking                         _legendDocking = Docking.Right;
                private int                                             _shadowOffset = 0;
                private Color                                   _shadowColor = Color.FromArgb(128, 0, 0, 0);
                private bool                                    _isTextAutoFit = true;
        private string                  _dockedToChartArea = Constants.NotSetValue;
                private bool                                    _isDockedInsideChartArea = true;

                //***********************************************************
                //** Private data members
                //***********************************************************

                // Collection of custom and series legend items
                internal LegendItemsCollection  legendItems = null;

                // Number of rows and columns
                private int             _itemColumns = 0;


                // Font calculated by auto fitting
                internal Font   autofitFont = null;

                // Indicates that all items in the legend should be equally spaced
                private bool    _isEquallySpacedItems = false;


                // Indicate that legend rows should be drawn with isInterlaced background color.
                private bool            _interlacedRows = false;

                // Legend isInterlaced rows color
                private Color           _interlacedRowsColor = Color.Empty;

                // Legend offsets
                private Size            _offset = Size.Empty;

                // Adjustment point used for legend animation
                private float           _maximumLegendAutoSize = 50f;

                // Text length after which the legend item text will be wrapped on the next whitespace.
                private int                     _textWrapThreshold = 25;

                // Value used to calculate auto-fit font size from the legend Font.
                private int                     _autoFitFontSizeAdjustment = 0;

                // Legend column collection
                private LegendCellColumnCollection _cellColumns = null;

                // Indicates that legend items automatically added based on the exsisting 
                // series in reversed order.
        private LegendItemOrder _legendItemOrder = LegendItemOrder.Auto;

                // Legend title text
                private string          _title = String.Empty;

                // Legend title color
                private Color           _titleForeColor = Color.Black;

                // Legend title back color
                private Color           _titleBackColor = Color.Empty;

                // Legend title font
                private Font            _titleFont = null;

                // Legend title alignment
                private StringAlignment         _titleAlignment = StringAlignment.Center;

                // Legend title visual separator
                private LegendSeparatorStyle    _titleSeparator = LegendSeparatorStyle.None;

                // Legend title visual separator color
                private Color           _titleSeparatorColor = Color.Black;

                // Legend header visual separator
                private LegendSeparatorStyle    _headerSeparator = LegendSeparatorStyle.None;

                // Legend header visual separator color
                private Color           _headerSeparatorColor = Color.Black;

                // Legend table columns visual separator
                private LegendSeparatorStyle    _itemColumnSeparator = LegendSeparatorStyle.None;

                // Legend table columns visual separator color
                private Color           _itemColumnSeparatorColor = Color.Black;

                // Legend table column spacing calculated as a percentage of the font
                private int                     _itemColumnSpacing = 50;

                // Legend table column spacing calculated in relative coordinates
                private int             _itemColumnSpacingRel = 0;

                // Legend title position in pixelcoordinates.
                // Note that legend title always docked to the top of the legend.
                private Rectangle       _titlePosition = Rectangle.Empty;

                // Legend header position in pixel coordinates.
                private Rectangle       _headerPosition = Rectangle.Empty;

                // Minimum font size that can be used by the legend auto-fitting algorithm
                private int                     _autoFitMinFontSize = 7;

                // Horizontal space left after fitting legend items
                private int             _horizontalSpaceLeft = 0;

                // Vertical space left after fitting legend items
                private int             _verticalSpaceLeft = 0;

                // Sub-columns sizes calculated during the fitting process
                private int[,]  _subColumnSizes = null;

                // Legend item heigts
                private int[,]  _cellHeights = null;

                // Number of rows per each legend table column
                private int[]           _numberOfRowsPerColumn = null;

                // Number of items from the collection that should be processed
                private int                     _numberOfLegendItemsToProcess = -1;

                // Legend items area position in pixels
                private Rectangle       _legendItemsAreaPosition = Rectangle.Empty;

                // Indicates that not all legend items were able to fit the legend
                private bool            _legendItemsTruncated = false;

                // Size of the dots (pixels) that will drawn on the bottom of the legend when it is truncated
                private int                     _truncatedDotsSize = 3;

                // Maximum number of cells in the legend item
                private int                     _numberOfCells = -1;

                // Pixel size of the 'W' character
                internal Size           singleWCharacterSize = Size.Empty;


                #endregion

                #region Constructors

                /// <summary>
                /// Legend constructor
                /// </summary>
                public Legend()
                {
            _position = new ElementPosition(this);
            // Initialize custom items collection
                        _customLegends = new LegendItemsCollection(this);
                        legendItems = new LegendItemsCollection(this);
                        _cellColumns = new LegendCellColumnCollection(this);
            _font = _fontCache.DefaultFont;
            _titleFont = _fontCache.DefaultBoldFont;
                }

        /// <summary>
        /// Legend constructor
        /// </summary>
        /// <param name="name">The legend name.</param>
        public Legend(string name) : base (name)
        {
            _position = new ElementPosition(this);
            // Initialize custom items collection
            _customLegends = new LegendItemsCollection(this);
            legendItems = new LegendItemsCollection(this);
            _cellColumns = new LegendCellColumnCollection(this);
            _font = _fontCache.DefaultFont;
            _titleFont = _fontCache.DefaultBoldFont;
        }

                #endregion

                #region Legend position & size methods

                /// <summary>
                /// Recalculates legend information:
                ///   - legend items collection
                ///   - maximum text rectangle
                /// </summary>
                /// <param name="chartGraph">Reference to the chart graphics.</param>
                private void RecalcLegendInfo(ChartGraphics chartGraph)
                {
                        // Reset some values
                        RectangleF      legendPositionRel = _position.ToRectangleF();
                        Rectangle       legendPosition = Rectangle.Round(chartGraph.GetAbsoluteRectangle(legendPositionRel));

                        //***********************************************************
                        //** Use size of the "W" characters in current font to 
                        //** calculate legend spacing
                        //***********************************************************
                        this.singleWCharacterSize =  chartGraph.MeasureStringAbs("W", this.Font);
                        Size doubleCharacterSize =  chartGraph.MeasureStringAbs("WW", this.Font);
                        this.singleWCharacterSize.Width = doubleCharacterSize.Width - this.singleWCharacterSize.Width;
                        
                        // Calculate left, top offset and column spacing
                        this._offset.Width = (int)Math.Ceiling(singleWCharacterSize.Width / 2f);
                        this._offset.Height = (int)Math.Ceiling(singleWCharacterSize.Width / 3f);

                        // Calculate item column spacing and make sure it is dividable by 2
                        this._itemColumnSpacingRel = (int)(singleWCharacterSize.Width * (this._itemColumnSpacing / 100f));
                        if(this._itemColumnSpacingRel % 2 == 1)
                        {
                                this._itemColumnSpacingRel += 1;
                        }

                        //***********************************************************
                        //** Calculate how much space required for the title.
                        //***********************************************************
                        this._titlePosition = Rectangle.Empty;
                        if(this.Title.Length > 0)
                        {
                                // Measure title text size
                                Size titleSize = this.GetTitleSize(chartGraph, legendPosition.Size);

                                // Set legend title position
                                this._titlePosition = new Rectangle(
                                        legendPosition.Location.X,
                                        legendPosition.Location.Y,
                                        legendPosition.Width,
                                        Math.Min(legendPosition.Height, titleSize.Height));

                                // Adjust legend items position height
                                legendPosition.Height -= this._titlePosition.Height;

                                // Increase title top location by border height
                                this._titlePosition.Y += this.GetBorderSize();
                        }


                        //***********************************************************
                        //** Calculate how much space required for the header.
                        //***********************************************************
                        this._headerPosition = Rectangle.Empty;

                        // Find the largest (height only) header
                        Size highestHeader = Size.Empty;
                        foreach(LegendCellColumn legendColumn in this.CellColumns)
                        {
                                if(legendColumn.HeaderText.Length > 0)
                                {
                                        // Measure header text size
                                        Size headerSize = this.GetHeaderSize(chartGraph, legendColumn);

                                        // Get header with maximum height
                                        highestHeader.Height = Math.Max(highestHeader.Height, headerSize.Height);
                                }
                        }

                        // Check if any headers where found
                        if(!highestHeader.IsEmpty)
                        {
                                // Set legend header position
                                this._headerPosition = new Rectangle(
                                        legendPosition.Location.X + this.GetBorderSize() + this._offset.Width,
                                        legendPosition.Location.Y + this._titlePosition.Height,
                                        legendPosition.Width - (this.GetBorderSize() + this._offset.Width) * 2,
                                        Math.Min(legendPosition.Height - this._titlePosition.Height, highestHeader.Height));
                                this._headerPosition.Height = Math.Max(this._headerPosition.Height, 0);

                                // Adjust legend items position height
                                legendPosition.Height -= this._headerPosition.Height;

                                // Increase header top location by border height
                                this._headerPosition.Y += this.GetBorderSize();
                        }


                        //***********************************************************
                        //** Calculate size available for all legend items
                        //***********************************************************
                        this._legendItemsAreaPosition = new Rectangle(
                                legendPosition.X + this._offset.Width + this.GetBorderSize(),
                                legendPosition.Y + this._offset.Height + this.GetBorderSize() + this._titlePosition.Height + this._headerPosition.Height,
                                legendPosition.Width - 2 * (this._offset.Width + this.GetBorderSize()),
                                legendPosition.Height - 2 * (this._offset.Height + this.GetBorderSize()) );

                        //***********************************************************
                        //** Calculate number of rows and columns depending on
                        //** the legend style
                        //***********************************************************
                        this.GetNumberOfRowsAndColumns(
                                chartGraph, 
                                this._legendItemsAreaPosition.Size,
                                -1,
                                out this._numberOfRowsPerColumn, 
                                out this._itemColumns,
                                out this._horizontalSpaceLeft,
                                out this._verticalSpaceLeft);

                        //***********************************************************
                        //** Try to fit all legend item cells reducing the font size
                        //***********************************************************

                        // Reset auto-fit font adjustment value and truncated legend flag
                        this._autoFitFontSizeAdjustment = 0;
                        this._legendItemsTruncated = false;

                        // Check if legend items fit into the legend area
                        bool autoFitDone = (this._horizontalSpaceLeft >= 0 && this._verticalSpaceLeft >= 0);

                        // Calculate total number of items fit and make sure we fit all of them
                        this._numberOfLegendItemsToProcess = this.legendItems.Count;
                        int itemsFit = 0;
                        for(int index = 0; index < this._itemColumns; index++)
                        {
                                itemsFit += this._numberOfRowsPerColumn[index];
                        }
                        if(itemsFit < this._numberOfLegendItemsToProcess)
                        {
                                autoFitDone = false;
                        }

            // If items do not fit try reducing font or number of legend items
            this.autofitFont = this.Font;
                        if(!autoFitDone)
                        {
                                do
                                {
                                        // Check if legend item font size can be reduced
                                        if(this.IsTextAutoFit && 
                                                (this.Font.Size - this._autoFitFontSizeAdjustment) > this._autoFitMinFontSize)
                                        {
                                                // Reduce font size by one 
                                                ++this._autoFitFontSizeAdjustment;

                                                // Calculate new font size
                                                int newFontSize = (int)Math.Round(this.Font.Size - this._autoFitFontSizeAdjustment);
                                                if(newFontSize < 1)
                                                {
                                                        // Font can't be less than size 1
                                                        newFontSize = 1;
                                                }

                        // Create new font
                        this.autofitFont = this.Common.ChartPicture.FontCache.GetFont(
                                                        this.Font.FontFamily, 
                                                        newFontSize, 
                                                        this.Font.Style, 
                                                        this.Font.Unit);

                                                // Calculate number of rows and columns 
                                                this.GetNumberOfRowsAndColumns(
                                                        chartGraph, 
                                                        this._legendItemsAreaPosition.Size,
                                                        -1,
                                                        out this._numberOfRowsPerColumn, 
                                                        out this._itemColumns,
                                                        out this._horizontalSpaceLeft,
                                                        out this._verticalSpaceLeft);

                                                autoFitDone = (this._horizontalSpaceLeft >= 0 && this._verticalSpaceLeft >= 0);

                                                // Calculate total number of items fit and make sure we fit all of them
                                                itemsFit = 0;
                                                for(int index = 0; index < this._itemColumns; index++)
                                                {
                                                        itemsFit += this._numberOfRowsPerColumn[index];
                                                }
                                                if(itemsFit < this._numberOfLegendItemsToProcess)
                                                {
                                                        autoFitDone = false;
                                                }

                                        }
                                        else
                                        {
                                                // If font size cannot be reduced start removing legend items
                                                if(this._numberOfLegendItemsToProcess > 2)
                                                {
                                                        // Handle case of 1 column that do not fit horizontally
                                                        if(this._itemColumns == 1 && (this._horizontalSpaceLeft < 0 && this._verticalSpaceLeft >= 0))
                                                        {
                                                                autoFitDone = true;
                                                                this._numberOfLegendItemsToProcess = 
                                                                        Math.Min(this._numberOfLegendItemsToProcess, this._numberOfRowsPerColumn[0]);
                                                        }
                                                        // Handle case of 1 row that do not fit vertically
                                                        else if(this.GetMaximumNumberOfRows() == 1 && (this._verticalSpaceLeft < 0  && this._horizontalSpaceLeft >= 0))
                                                        {
                                                                autoFitDone = true;
                                                                this._numberOfLegendItemsToProcess = 
                                                                        Math.Min(this._numberOfLegendItemsToProcess, this._itemColumns);
                                                        }
                                                        else
                                                        {
                                                                // Adjust legend items area height by size required to show
                                                                // visually (dots) that legend is truncated
                                                                if(!this._legendItemsTruncated)
                                                                {
                                                                        this._legendItemsAreaPosition.Height -= this._truncatedDotsSize;
                                                                }

                                                                // Remove last legend item
                                                                this._legendItemsTruncated = true;
                                                                --this._numberOfLegendItemsToProcess;

                                                                // RecalculateAxesScale number of rows and columns
                                                                this.GetNumberOfRowsAndColumns(
                                                                        chartGraph, 
                                                                        this._legendItemsAreaPosition.Size,
                                                                        this._numberOfLegendItemsToProcess,
                                                                        out this._numberOfRowsPerColumn, 
                                                                        out this._itemColumns);
                                                        }

                                                        // Make sure we show truncated legend symbols when not all items shown
                                                        if(autoFitDone && 
                                                                !this._legendItemsTruncated &&
                                                                this._numberOfLegendItemsToProcess < this.legendItems.Count)
                                                        {
                                                                // Adjust legend items area height by size required to show
                                                                // visually (dots) that legend is truncated
                                                                this._legendItemsAreaPosition.Height -= this._truncatedDotsSize;

                                                                // Legend is truncated
                                                                this._legendItemsTruncated = true;
                                                        }
                                                }
                                                else
                                                {
                                                        autoFitDone = true;
                                                }
                                        
                                                // Check if legend items fit into the legend area
                                                if(!autoFitDone)
                                                {
                                                        autoFitDone = this.CheckLegendItemsFit(
                                                                chartGraph,
                                                                this._legendItemsAreaPosition.Size,
                                                                this._numberOfLegendItemsToProcess,
                                                                this._autoFitFontSizeAdjustment,
                                                                this._itemColumns,
                                                                this._numberOfRowsPerColumn,
                                                                out this._subColumnSizes,
                                                                out this._cellHeights,
                                                                out this._horizontalSpaceLeft,
                                                                out this._verticalSpaceLeft);

                                                }
                                        }
                                } while(!autoFitDone);
                        }

                
                        //***********************************************************
                        //** Calculate position of all cells
                        //***********************************************************

                        // Calculate item vertical spacing in relative coordinates but rounded on pixel boundary
                        Size itemHalfSpacing = Size.Empty;
                        if(this._verticalSpaceLeft > 0)
                        {
                                itemHalfSpacing.Height = (int)(this._verticalSpaceLeft / this.GetMaximumNumberOfRows() / 2);
                        }
                        if(this._horizontalSpaceLeft > 0)
                        {
                                itemHalfSpacing.Width = (int)(_horizontalSpaceLeft / 2);
                        }

                        // Iterate through all legend items
                        int currentColumn = 0;
                        int currentRow = 0;
                        if(this._numberOfLegendItemsToProcess < 0)
                        {
                                this._numberOfLegendItemsToProcess = this.legendItems.Count;
                        }
                        for(int legendItemIndex = 0; legendItemIndex < this._numberOfLegendItemsToProcess; legendItemIndex++)
                        {
                                LegendItem legendItem = this.legendItems[legendItemIndex];

                                // Iterate through legend item cells
                                for(int cellIndex = 0; cellIndex < legendItem.Cells.Count; cellIndex++)
                                {
                                        // Get legend cell
                                        LegendCell legendCell = legendItem.Cells[cellIndex];

                                        // Calculate cell position
                                        Rectangle cellPosition = this.GetCellPosition(currentColumn, currentRow, cellIndex, itemHalfSpacing);

                                        // Check if current cell spans through more than 1 cell
                                        int overlappedCellsNumber = 0;
                                        if(legendCell.CellSpan > 1)
                                        {
                                                for(int spanIndex = 1; spanIndex < legendCell.CellSpan && (cellIndex + spanIndex) < legendItem.Cells.Count; spanIndex++)
                                                {
                                                        // Calculate overlapped cell position
                                                        Rectangle overlappedCellPosition = this.GetCellPosition(currentColumn, currentRow, cellIndex + spanIndex, itemHalfSpacing);

                                                        // Adjust current cell right position
                                                        if(cellPosition.Right < overlappedCellPosition.Right)
                                                        {
                                                                cellPosition.Width += overlappedCellPosition.Right - cellPosition.Right;
                                                        }

                                                        // Increase number of overlapped cells
                                                        ++overlappedCellsNumber;

                                                        // Set empty size for the overlapped cells
                                                        LegendCell overlappedLegendCell = legendItem.Cells[cellIndex + spanIndex];
                                                        overlappedLegendCell.SetCellPosition( 
                                                                currentRow,
                                                                Rectangle.Empty, 
                                                                this.singleWCharacterSize);
                                                }
                                        }

                                        // Make sure cell is drawn inside the legend
                                        cellPosition.Intersect(this._legendItemsAreaPosition);

                                        // Set cell object position
                                        legendCell.SetCellPosition(
                                                currentRow,
                                                cellPosition, 
                                                this.singleWCharacterSize);

                                        // Skip overlapped cells
                                        cellIndex += overlappedCellsNumber;
                                }

                                // Advance to the next row/column. Break if number of legend items exceed
                                // number of availabale rows/columns.
                                ++currentRow;
                                if(currentRow >= this._numberOfRowsPerColumn[currentColumn])
                                {
                                        ++currentColumn;
                                        currentRow = 0;
                                        if(currentColumn >= this._itemColumns)
                                        {
                                                break;
                                        }
                                }
                        }
                }

                /// <summary>
                /// Gets single cell position in relative coordinates.
                /// </summary>
                /// <param name="columnIndex">Cell column index.</param>
                /// <param name="rowIndex">Cell row index.</param>
                /// <param name="cellIndex">Index of the cell in the legend item.</param>
                /// <param name="itemHalfSpacing">Half legend item spacing in relative coordinates.</param>
                /// <returns></returns>
                private Rectangle GetCellPosition( 
                        int columnIndex, 
                        int rowIndex, 
                        int cellIndex,
                        Size itemHalfSpacing)
                {
                        Rectangle cellPosition = this._legendItemsAreaPosition;

                        //*****************************************************************
                        //** Get cell Top location
                        //*****************************************************************
                        for(int index = 0; index < rowIndex; index++)
                        {
                                cellPosition.Y += this._cellHeights[columnIndex, index];
                        }
                        if(itemHalfSpacing.Height > 0)
                        {
                                cellPosition.Y += itemHalfSpacing.Height * rowIndex * 2 + itemHalfSpacing.Height;
                        }

                        //*****************************************************************
                        //** Get cell Left location
                        //*****************************************************************

                        // Add extar space left after auto fitting
                        if(this._horizontalSpaceLeft > 0)
                        {
                                cellPosition.X += itemHalfSpacing.Width;
                        }

                        // Calculate how many sub-columns (cells) this legend has
                        int numberOfSubColumns = this.GetNumberOfCells();

                        // Iterate through all prev. columns
                        for(int index = 0; index < columnIndex; index++)
                        {
                                // Add width of previous columns
                                for(int subColumnIndex = 0; subColumnIndex < numberOfSubColumns; subColumnIndex++)
                                {
                                        cellPosition.X += this._subColumnSizes[index, subColumnIndex];
                                }

                                // Add width of separator for the previous columns
                                cellPosition.X += this.GetSeparatorSize(this.ItemColumnSeparator).Width;
                        }
                        // Add width of current column cells
                        for(int subColumnIndex = 0; subColumnIndex < cellIndex; subColumnIndex++)
                        {
                                cellPosition.X += this._subColumnSizes[columnIndex, subColumnIndex];
                        }

                        //*****************************************************************
                        //** Get cell Height
                        //*****************************************************************
                        cellPosition.Height = this._cellHeights[columnIndex, rowIndex];
                        
                        //*****************************************************************
                        //** Get cell Width
                        //*****************************************************************
                        cellPosition.Width = this._subColumnSizes[columnIndex, cellIndex];

                        return cellPosition;
                }

                /// <summary>
                /// Calculates the optimal size of the legend.
                /// </summary>
                /// <param name="chartGraph">Chart graphics object.</param>
                /// <param name="maxSizeRel">Max size for the legend.</param>
                /// <returns>Legend optimal size.</returns>
                private SizeF GetOptimalSize(ChartGraphics chartGraph, SizeF maxSizeRel)
                {
                        // Reset some values
                        this._offset = Size.Empty;
                        this._itemColumns = 0;
                        this._horizontalSpaceLeft = 0;
                        this._verticalSpaceLeft = 0;
                        this._subColumnSizes = null;
                        this._numberOfRowsPerColumn = null;
                        this._cellHeights = null;
                        this.autofitFont = null;
                        this._autoFitFontSizeAdjustment = 0;
                        this._numberOfCells = -1;
                        this._numberOfLegendItemsToProcess = -1;
                        Size    optimalSize = Size.Empty;

                        // Convert to pixels
                        SizeF maxSizeAbs = chartGraph.GetAbsoluteSize(maxSizeRel);
                        Size maxSize = new Size((int)maxSizeAbs.Width, (int)maxSizeAbs.Height);

                        // Clear all legend item cells cached information
                        foreach(LegendItem legendItem in this.legendItems)
                        {
                                foreach(LegendCell cell in legendItem.Cells)
                                {
                                        cell.ResetCache();
                                }
                        }

                        // Check if legend is enabled
                        if(this.IsEnabled())
                        {
                                // Add all series legend into items collection and then add custom legend items
                                FillLegendItemsCollection();

                                // Call a notification event, so that legend items collection can be modified by user
                this.Common.Chart.CallOnCustomizeLegend(legendItems, this.Name);

                                // Check if there are any items in the legend
                                if(this.legendItems.Count > 0)
                                {
                                        //***********************************************************
                                        //** Use size of the "W" character in current font to 
                                        //** calculate legend spacing
                                        //***********************************************************
                                        this.singleWCharacterSize =  chartGraph.MeasureStringAbs("W", this.Font);
                                        Size doubleCharacterSize =  chartGraph.MeasureStringAbs("WW", this.Font);
                                        this.singleWCharacterSize.Width = doubleCharacterSize.Width - this.singleWCharacterSize.Width;
                        
                                        // Calculate left, top offset and column spacing
                                        this._offset.Width = (int)Math.Ceiling(singleWCharacterSize.Width / 2f);
                                        this._offset.Height = (int)Math.Ceiling(singleWCharacterSize.Width / 3f);
                                        this._itemColumnSpacingRel = (int)(singleWCharacterSize.Width * (this._itemColumnSpacing / 100f));
                                        if(this._itemColumnSpacingRel % 2 == 1)
                                        {
                                                this._itemColumnSpacingRel += 1;
                                        }


                                        //***********************************************************
                                        //** Add size required for the legend tile
                                        //***********************************************************
                                        
                                        Size titleSize = Size.Empty;
                                        if(this.Title.Length > 0)
                                        {
                                                titleSize = this.GetTitleSize(chartGraph, maxSize);
                                        }

                                        //***********************************************************
                                        //** Add size required for the legend header
                                        //***********************************************************

                                        Size highestHeader = Size.Empty;
                                        foreach(LegendCellColumn legendColumn in this.CellColumns)
                                        {
                                                if(legendColumn.HeaderText.Length > 0)
                                                {
                                                        // Measure header text size
                                                        Size headerSize = this.GetHeaderSize(chartGraph, legendColumn);

                                                        // Get header with maximum height
                                                        highestHeader.Height = Math.Max(highestHeader.Height, headerSize.Height);
                                                }
                                        }

                                        //***********************************************************
                                        //** Calculate size available for legend items
                                        //***********************************************************
                                        Size legenItemsMaxSize = maxSize;
                                        legenItemsMaxSize.Width -= 2 * (this._offset.Width + this.GetBorderSize());
                                        legenItemsMaxSize.Height -= 2 * (this._offset.Height + this.GetBorderSize());
                                        legenItemsMaxSize.Height -= titleSize.Height;
                                        legenItemsMaxSize.Height -= highestHeader.Height;

                                        //***********************************************************
                                        //** Calculate number of rows and columns depending on
                                        //** the legend style
                                        //***********************************************************
                    this._autoFitFontSizeAdjustment = 0;

                                        this.autofitFont = this.Font;
                                        int vertSpaceLeft = 0;
                                        int horizSpaceLeft = 0;
                                        bool reduceFont = this.IsTextAutoFit;
                                        bool autoFit = false;
                                        do
                                        {
                                                // Get number of columns and rows that we can fit in the legend
                                                this.GetNumberOfRowsAndColumns(
                                                        chartGraph, 
                                                        legenItemsMaxSize,
                                                        -1,
                                                        out this._numberOfRowsPerColumn, 
                                                        out this._itemColumns,
                                                        out horizSpaceLeft,
                                                        out vertSpaceLeft);

                                                // Calculate total number of items fit and make sure we fit all of them
                                                int itemsFit = 0;
                                                for(int index = 0; index < this._itemColumns; index++)
                                                {
                                                        itemsFit += this._numberOfRowsPerColumn[index];
                                                }
                                                autoFit = (horizSpaceLeft >= 0 && vertSpaceLeft >= 0 && itemsFit >= this.legendItems.Count);

                                                // Check if items fit
                                                if(reduceFont && !autoFit)
                                                {
                                                        if((this.Font.Size - this._autoFitFontSizeAdjustment) > this._autoFitMinFontSize)
                                                        {
                                                                // Reduce font size by one 
                                                                ++this._autoFitFontSizeAdjustment;

                                                                // Calculate new font size
                                                                int newFontSize = (int)Math.Round(this.Font.Size - this._autoFitFontSizeAdjustment);
                                                                if(newFontSize < 1)
                                                                {
                                                                        // Font can't be less than size 1
                                                                        newFontSize = 1;
                                                                }

                                                                // Create new font
                                this.autofitFont = this.Common.ChartPicture.FontCache.GetFont(
                                                                        this.Font.FontFamily, 
                                                                        newFontSize, 
                                                                        this.Font.Style, 
                                                                        this.Font.Unit);
                                                        }
                                                        else
                                                        {
                                                                reduceFont = false;
                                                        }
                                                }
                                        } while(reduceFont && !autoFit);

                                        // Slightly reduce used space 
                                        horizSpaceLeft -= Math.Min(4, horizSpaceLeft);
                                        vertSpaceLeft -= Math.Min(2, vertSpaceLeft);

        
                                        //***********************************************************
                                        //** Calculate legend size
                                        //***********************************************************
                                        optimalSize.Width = (legenItemsMaxSize.Width - horizSpaceLeft);
                                        optimalSize.Width = Math.Max(optimalSize.Width, titleSize.Width);
                                        optimalSize.Width += 2 * (this._offset.Width + this.GetBorderSize());

                                        optimalSize.Height = (legenItemsMaxSize.Height - vertSpaceLeft) + titleSize.Height + highestHeader.Height;
                                        optimalSize.Height += 2 * (this._offset.Height + this.GetBorderSize());

                                        // Adjust legend items area height by size required to show
                                        // visually (dots) that legend is truncated
                                        if(horizSpaceLeft < 0 || vertSpaceLeft < 0)
                                        {
                                                optimalSize.Height += this._truncatedDotsSize;
                                        }

                                        //***********************************************************
                                        //** Make sure legend size do not exceed max. value
                                        //***********************************************************
                                        if(optimalSize.Width > maxSize.Width)
                                        {
                                                optimalSize.Width = maxSize.Width;
                                        }
                                        if(optimalSize.Height > maxSize.Height)
                                        {
                                                optimalSize.Height = maxSize.Height;
                                        }
                                        if(optimalSize.Width < 0)
                                        {
                                                optimalSize.Width = 0;
                                        }
                                        if(optimalSize.Height < 0)
                                        {
                                                optimalSize.Height = 0;
                                        }
                                }
                        }

                        // Convert result size from pixel to relative coordinates
                        return chartGraph.GetRelativeSize(optimalSize);
                }



                /// <summary>
                /// Recalculates legend position.
                /// </summary>
                /// <param name="chartGraph">Chart graphics used.</param>
                /// <param name="chartAreasRectangle">Area where the legend should be positioned.</param>
                /// <param name="elementSpacing">Spacing size as a percentage of the area.</param>
                internal void CalcLegendPosition(
                        ChartGraphics chartGraph, 
                        ref RectangleF chartAreasRectangle, 
                        float elementSpacing)
                {
                        RectangleF      legendPosition = new RectangleF();

                        // Get optimal legend size
                        SizeF maxSize = new SizeF(chartAreasRectangle.Width - 2*elementSpacing, chartAreasRectangle.Height - 2*elementSpacing);
            if (this.DockedToChartArea == Constants.NotSetValue)
                        {

                // Note: 'maxLegendSize' parameter is ignored. New legend property 
                // 'maximumLegendAutoSize' is used instead.
                                if(this.Docking == Docking.Top || this.Docking == Docking.Bottom)
                                {
                    maxSize.Height = (maxSize.Height / 100F) * this._maximumLegendAutoSize;
                                }
                                else
                                {
                    maxSize.Width = (maxSize.Width / 100F) * this._maximumLegendAutoSize;
                                }
                        }

                        if(maxSize.Width <= 0 || maxSize.Height <= 0)
                        {
                                return;
                        }
                                
                        SizeF legendSize = this.GetOptimalSize(chartGraph, maxSize);
                        legendPosition.Height = legendSize.Height;
                        legendPosition.Width = legendSize.Width;
                        if(float.IsNaN(legendSize.Height) || float.IsNaN(legendSize.Width))
                        {
                                return;
                        }

                        // Calculate legend position
                        if(this.Docking == Docking.Top)
                        {
                                legendPosition.Y = chartAreasRectangle.Y + elementSpacing;
                                if(this.Alignment == StringAlignment.Near)
                                {
                                        legendPosition.X = chartAreasRectangle.X + elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Far)
                                {
                                        legendPosition.X = chartAreasRectangle.Right - legendSize.Width - elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Center)
                                {
                                        legendPosition.X = chartAreasRectangle.X + (chartAreasRectangle.Width - legendSize.Width) / 2F;
                                }

                                // Adjust position of the chart area(s)
                                chartAreasRectangle.Height -= legendPosition.Height + elementSpacing;
                                chartAreasRectangle.Y = legendPosition.Bottom;
                        }
                        else if(this.Docking == Docking.Bottom)
                        {
                                legendPosition.Y = chartAreasRectangle.Bottom - legendSize.Height - elementSpacing;
                                if(this.Alignment == StringAlignment.Near)
                                {
                                        legendPosition.X = chartAreasRectangle.X + elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Far)
                                {
                                        legendPosition.X = chartAreasRectangle.Right - legendSize.Width - elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Center)
                                {
                                        legendPosition.X = chartAreasRectangle.X + (chartAreasRectangle.Width - legendSize.Width) / 2F;
                                }

                                // Adjust position of the chart area(s)
                                chartAreasRectangle.Height -= legendPosition.Height + elementSpacing;
                        }
                        if(this.Docking == Docking.Left)
                        {
                                legendPosition.X = chartAreasRectangle.X + elementSpacing;
                                if(this.Alignment == StringAlignment.Near)
                                {
                                        legendPosition.Y = chartAreasRectangle.Y + elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Far)
                                {
                                        legendPosition.Y = chartAreasRectangle.Bottom - legendSize.Height - elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Center)
                                {
                                        legendPosition.Y = chartAreasRectangle.Y + (chartAreasRectangle.Height - legendSize.Height) / 2F;
                                }

                                // Adjust position of the chart area(s)
                                chartAreasRectangle.Width -= legendPosition.Width + elementSpacing;
                                chartAreasRectangle.X = legendPosition.Right;
                        }
                        if(this.Docking == Docking.Right)
                        {
                                legendPosition.X = chartAreasRectangle.Right - legendSize.Width - elementSpacing;
                                if(this.Alignment == StringAlignment.Near)
                                {
                                        legendPosition.Y = chartAreasRectangle.Y + elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Far)
                                {
                                        legendPosition.Y = chartAreasRectangle.Bottom - legendSize.Height - elementSpacing;
                                }
                                else if(this.Alignment == StringAlignment.Center)
                                {
                                        legendPosition.Y = chartAreasRectangle.Y + (chartAreasRectangle.Height - legendSize.Height) / 2F;
                                }

                                // Adjust position of the chart area(s)
                                chartAreasRectangle.Width -= legendPosition.Width + elementSpacing;
                        }

                        this.Position.SetPositionNoAuto(legendPosition.X, legendPosition.Y, legendPosition.Width, legendPosition.Height);
                }



                /// <summary>
                /// Get number of columns and rows that can be fit in specified size.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="legendSize">Legend size.</param>
                /// <param name="numberOfItemsToCheck">Number of legend items to check.</param>
                /// <param name="numberOfRowsPerColumn">Array with number of rows per each column.</param>
                /// <param name="columnNumber">Returns number of columns.</param>
                private void GetNumberOfRowsAndColumns(
                        ChartGraphics chartGraph, 
                        Size legendSize,
                        int numberOfItemsToCheck,
                        out int[] numberOfRowsPerColumn, 
                        out int columnNumber)
                {
                        int horSpaceLeft = 0;
                        int vertSpaceLeft = 0;
                        this.GetNumberOfRowsAndColumns(
                                chartGraph, 
                                legendSize,
                                numberOfItemsToCheck,
                                out numberOfRowsPerColumn, 
                                out columnNumber,
                                out horSpaceLeft,
                                out vertSpaceLeft);
                }

                /// <summary>
                /// Get number of columns and rows that can be fit in specified size.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="legendSize">Legend size.</param>
                /// <param name="numberOfItemsToCheck">Legend items number to check.</param>
                /// <param name="numberOfRowsPerColumn">Array with number of rows per each column.</param>
                /// <param name="columnNumber">Returns number of columns.</param>
                /// <param name="horSpaceLeft">Returns horizontal spacing left.</param>
                /// <param name="vertSpaceLeft">Returns vertical spacing left.</param>
                private void GetNumberOfRowsAndColumns(
                        ChartGraphics chartGraph, 
                        Size legendSize,
                        int numberOfItemsToCheck,
                        out int[] numberOfRowsPerColumn, 
                        out int columnNumber,
                        out int horSpaceLeft,
                        out int vertSpaceLeft)
                {
                        // Initialize output parameters
                        numberOfRowsPerColumn = null;
                        columnNumber = 1;
                        horSpaceLeft = 0;
                        vertSpaceLeft = 0;

                        // If number of items to check is nor set use total number of items in the collection
                        if(numberOfItemsToCheck < 0)
                        {
                                numberOfItemsToCheck = legendItems.Count;
                        }

                        // Check legend style
                        if(this.LegendStyle == LegendStyle.Column || numberOfItemsToCheck <= 1)
                        {
                                columnNumber = 1;
                                numberOfRowsPerColumn = new int[] { numberOfItemsToCheck };
                        }
                        else if(this.LegendStyle == LegendStyle.Row)
                        {
                                columnNumber = numberOfItemsToCheck;
                                numberOfRowsPerColumn = new int[columnNumber];
                                for(int index = 0; index < columnNumber; index++)
                                {
                                        numberOfRowsPerColumn[index] = 1;
                                }
                        }
                        else if(this.LegendStyle == LegendStyle.Table)
                        {
                                // Start with 1 column and 1 row
                                columnNumber = 1;
                                numberOfRowsPerColumn = new int[] { 1 };

                                // Get legend table style and adjust number of columns and rows accordinly
                                LegendTableStyle tableStyle = this.GetLegendTableStyle(chartGraph);
                                
                                //*********************************************************************************
                                //** Tall table layout
                                //*********************************************************************************
                                if(tableStyle == LegendTableStyle.Tall)
                                {
                                        // Iterate from second item trying to add them and check if their fit
                                        bool exitLoop = false;
                                        int legendItemIndex = 1;
                                        for(legendItemIndex = 1; !exitLoop && legendItemIndex < numberOfItemsToCheck; legendItemIndex ++)
                                        {
                                                // Try to increase number of rows in the current column
                                                ++numberOfRowsPerColumn[columnNumber - 1];

                                                // Check if legend items fit into the legend area
                                                bool autoFitDone = this.CheckLegendItemsFit(
                                                        chartGraph,
                                                        legendSize,
                                                        legendItemIndex + 1,
                                                        this._autoFitFontSizeAdjustment,
                                                        columnNumber,
                                                        numberOfRowsPerColumn,
                                                        out this._subColumnSizes,
                                                        out this._cellHeights,
                                                        out horSpaceLeft,
                                                        out vertSpaceLeft);

                                                // Check if we fit or if we have just one column that do not fit
                                                // horizontally but still have vertical space.
                                                if(autoFitDone || 
                                                        ( (columnNumber == 1 || horSpaceLeft < 0) && vertSpaceLeft > 0) )
                                                {
                                                        // Continue adding rows to the current column
                                                        continue;
                                                }
                                                else
                                                {
                                                        // Reduce number of rows in the current column
                                                        if(numberOfRowsPerColumn[columnNumber - 1] > 1)
                                                        {
                                                                --numberOfRowsPerColumn[columnNumber - 1];
                                                        }

                                                        // Get half of average column width
                                                        int averageColumnWidth = 0;
                                                        if(horSpaceLeft > 0)
                                                        {
                                                                averageColumnWidth = (int)Math.Round((double)(legendSize.Width - horSpaceLeft) / columnNumber) / 2;
                                                        }

                                                         // Check if number of columns can be increased
                                                        if(columnNumber < 50 && horSpaceLeft >= averageColumnWidth)
                                                        {
                                                                // Add new column
                                                                ++columnNumber;

                                                                // Resize array that stores number of rows per column
                                                                int[] tempArray = numberOfRowsPerColumn;
                                                                numberOfRowsPerColumn = new int[columnNumber];
                                                                for(int index = 0; index < tempArray.Length; index++)
                                                                {
                                                                        numberOfRowsPerColumn[index] = tempArray[index];
                                                                }
                                                                numberOfRowsPerColumn[columnNumber - 1] = 1;

                                                                // If last legend item is moved into a new column
                                                                // call the auto fitting method before leaving the loop
                                                                if(legendItemIndex == numberOfItemsToCheck - 1)
                                                                {
                                                                        this.CheckLegendItemsFit(
                                                                                chartGraph,
                                                                                legendSize,
                                                                                legendItemIndex + 1,
                                                                                this._autoFitFontSizeAdjustment,
                                                                                columnNumber,
                                                                                numberOfRowsPerColumn,
                                                                                out this._subColumnSizes,
                                                                                out this._cellHeights,
                                                                                out horSpaceLeft,
                                                                                out vertSpaceLeft);
                                                                }
                                                        }
                                                        else
                                                        {
                                                                exitLoop = true;
                                                        }
                                                }
                                        }

                                        // Check if we end up with legend with multiple columns
                                        // where last column has sinificantly lower height of all rows
                                        if(columnNumber > 1)
                                        {
                                                // Try reducing number of rows in the "tall" calumns and move them 
                                                // into the last column.
                                                bool done = false;
                                                while(!done)
                                                {
                                                        // By default no more iterations required
                                                        done = true;

                                                        // Find maximum column height not taking the last row in consideration
                                                        int maxColumnHeight = -1;
                                                        for(int columnIndex = 0; columnIndex < columnNumber; columnIndex++)
                                                        {
                                                                // Calculate current column height not taking the last row in consideration
                                                                int columnHeight = 0;
                                                                for(int rowIndex = 0; rowIndex < this._numberOfRowsPerColumn[columnIndex] - 1; rowIndex++)
                                                                {
                                                                        columnHeight += this._cellHeights[columnIndex, rowIndex];
                                                                }

                                                                // Find maximum height
                                                                maxColumnHeight = Math.Max(maxColumnHeight, columnHeight);
                                                        }

                                                        // Calculate total height of items in the last row
                                                        int totalHieghtOfItemInLastRow = 0;
                                                        for(int columnIndex = 0; columnIndex < (columnNumber - 1); columnIndex++)
                                                        {
                                                                if(this._numberOfRowsPerColumn[columnIndex] > 1)
                                                                {
                                                                        totalHieghtOfItemInLastRow += this._cellHeights[columnIndex, this._numberOfRowsPerColumn[columnIndex] - 1];
                                                                }
                                                        }

                                                        // Check if rows are available for removal
                                                        if(totalHieghtOfItemInLastRow > 0)
                                                        {
                                                                // Get last column height
                                                                int lastColumnHeight = this.GetColumnHeight(columnNumber - 1);

                                                                // Check if all items in the last row can vertically fit in last column
                                                                if( (lastColumnHeight + totalHieghtOfItemInLastRow) <= maxColumnHeight )
                                                                {
                                                                        // Reduce number of rows in all columns except last
                                                                        int itemsToAdd = 0;
                                                                        for(int columnIndex = 0; columnIndex < (columnNumber - 1); columnIndex++)
                                                                        {
                                                                                if(this._numberOfRowsPerColumn[columnIndex] > 1)
                                                                                {
                                                                                        --this._numberOfRowsPerColumn[columnIndex];
                                                                                        ++itemsToAdd;
                                                                                }
                                                                        }

                                                                        // Add rows to last column
                                                                        if(itemsToAdd > 0)
                                                                        {
                                                                                // Add roes into the last column
                                                                                this._numberOfRowsPerColumn[columnNumber - 1] += itemsToAdd;

                                                                                // Check if legend items fit into the legend area
                                                                                bool autoFitDone = this.CheckLegendItemsFit(
                                                                                        chartGraph,
                                                                                        legendSize,
                                                                                        legendItemIndex + 1,
                                                                                        this._autoFitFontSizeAdjustment,
                                                                                        columnNumber,
                                                                                        numberOfRowsPerColumn,
                                                                                        out this._subColumnSizes,
                                                                                        out this._cellHeights,
                                                                                        out horSpaceLeft,
                                                                                        out vertSpaceLeft);

                                                                                // Try doing one more time
                                                                                done = false;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                        //*********************************************************************************
                                        //** Wide table layout
                                        //*********************************************************************************
                                else if(tableStyle == LegendTableStyle.Wide)
                                {
                                        // Iterate from second item trying to add them and check if they fit
                                        bool exitLoop = false;
                                        int legendItemIndex = 1;
                                        for(legendItemIndex = 1; !exitLoop && legendItemIndex < numberOfItemsToCheck; legendItemIndex ++)
                                        {
                                                // Try to increase number of columns
                                                ++columnNumber;

                                                // Resize array that stores number of rows per column
                                                int[] tempArray = numberOfRowsPerColumn;
                                                numberOfRowsPerColumn = new int[columnNumber];
                                                for(int index = 0; index < tempArray.Length; index++)
                                                {
                                                        numberOfRowsPerColumn[index] = tempArray[index];
                                                }
                                                numberOfRowsPerColumn[columnNumber - 1] = 1;

                                                // Check if legend items fit into the legend area
                                                bool autoFitDone = this.CheckLegendItemsFit(
                                                        chartGraph,
                                                        legendSize,
                                                        legendItemIndex + 1,
                                                        this._autoFitFontSizeAdjustment,
                                                        columnNumber,
                                                        numberOfRowsPerColumn,
                                                        out this._subColumnSizes,
                                                        out this._cellHeights,
                                                        out horSpaceLeft,
                                                        out vertSpaceLeft);

                                                // Check if we fit or if we have just one row that do not fit
                                                // vertically but still have horizontal space.
                                                if(autoFitDone || 
                                                        ( (this.GetMaximumNumberOfRows(numberOfRowsPerColumn) == 1 || vertSpaceLeft < 0) && horSpaceLeft > 0) )
                                                {
                                                        // Continue adding columns
                                                        continue;
                                                }
                                                else
                                                {
                                                        // Remove columns and increase number of rows
                                                        bool columnFitting = true;
                                                        while(columnFitting)
                                                        {
                                                                columnFitting = false;

                                                                // If we can't fit current number of columns reduce current column number
                                                                int rowsToAdd = 0;
                                                                if(columnNumber > 1)
                                                                {
                                                                        rowsToAdd = numberOfRowsPerColumn[columnNumber - 1];
                                                                        --columnNumber;

                                                                        // Resize array that stores number of rows per column
                                                                        tempArray = numberOfRowsPerColumn;
                                                                        numberOfRowsPerColumn = new int[columnNumber];
                                                                        for(int index = 0; index < columnNumber; index++)
                                                                        {
                                                                                numberOfRowsPerColumn[index] = tempArray[index];
                                                                        }
                                                                }

                                                                // We may need to add more than 1 row
                                                                for(int indexRowToAdd = 0; indexRowToAdd < rowsToAdd; indexRowToAdd++)
                                                                {
                                                                        // Find first column with smallest height
                                                                        int smallestColumnIndex = -1;
                                                                        int columnMinHeight = int.MaxValue;
                                                                        for(int columnIndex = 0; columnIndex < columnNumber; columnIndex++)
                                                                        {
                                                                                int columnHeight = this.GetColumnHeight(columnIndex);
                                                                                int nextColumnFirstItemHeight = 0;
                                                                                if(columnIndex < columnNumber - 1)
                                                                                {
                                                                                        nextColumnFirstItemHeight = this._cellHeights[columnIndex + 1, 0];
                                                                                }
                                                                                if(columnHeight < columnMinHeight && 
                                                                                        (columnHeight + nextColumnFirstItemHeight) < legendSize.Height)
                                                                                {
                                                                                        // Remember column index and height
                                                                                        columnMinHeight = columnHeight;
                                                                                        smallestColumnIndex = columnIndex;
                                                                                }
                                                                        }

                                                                        // No more items can fit
                                                                        if(smallestColumnIndex < 0)
                                                                        {
                                                                                // Check if legend items fit into the legend area
                                                                                autoFitDone = this.CheckLegendItemsFit(
                                                                                        chartGraph,
                                                                                        legendSize,
                                                                                        legendItemIndex + 1,
                                                                                        this._autoFitFontSizeAdjustment,
                                                                                        columnNumber,
                                                                                        numberOfRowsPerColumn,
                                                                                        out this._subColumnSizes,
                                                                                        out this._cellHeights,
                                                                                        out horSpaceLeft,
                                                                                        out vertSpaceLeft);

                                                                                exitLoop = true;
                                                                                break;
                                                                        }

                                                                        // Add new row to the smallest column
                                                                        ++numberOfRowsPerColumn[smallestColumnIndex];

                                                                        // Check if next column will be removed if it contains only 1 row
                                                                        if(smallestColumnIndex < (columnNumber - 1))
                                                                        {
                                                                                if(numberOfRowsPerColumn[smallestColumnIndex + 1] == 1)
                                                                                {
                                                                                        // Shift number of rows per column
                                                                                        tempArray = numberOfRowsPerColumn;
                                                                                        for(int index = smallestColumnIndex + 1; index < tempArray.Length - 1; index++)
                                                                                        {
                                                                                                numberOfRowsPerColumn[index] = tempArray[index + 1];
                                                                                        }
                                                                                        numberOfRowsPerColumn[columnNumber - 1] = 1;
                                                                                }
                                                                        }

                                                                        // Check if legend items fit into the legend area
                                                                        autoFitDone = this.CheckLegendItemsFit(
                                                                                chartGraph,
                                                                                legendSize,
                                                                                legendItemIndex + 1,
                                                                                this._autoFitFontSizeAdjustment,
                                                                                columnNumber,
                                                                                numberOfRowsPerColumn,
                                                                                out this._subColumnSizes,
                                                                                out this._cellHeights,
                                                                                out horSpaceLeft,
                                                                                out vertSpaceLeft);

                                                                }

                                                                // If there is more than 1 column and items do not fit
                                                                // horizontally - reduce number of columns.
                                                                if(!autoFitDone && 
                                                                        horSpaceLeft < 0f && 
                                                                        columnNumber > 1)
                                                                {
                                                                        columnFitting = true;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        // Check if items fit and how much empty space left
                        this.CheckLegendItemsFit(
                                chartGraph,
                                legendSize,
                                -1,
                                this._autoFitFontSizeAdjustment,
                                columnNumber,
                                numberOfRowsPerColumn,
                                out this._subColumnSizes,
                                out this._cellHeights,
                                out horSpaceLeft,
                                out vertSpaceLeft);
                }
                
        /// <summary>
                /// Gets column height.
                /// </summary>
                /// <param name="columnIndex">Index of the column to get the height for.</param>
                /// <returns>Column height in relative coordinates.</returns>
                private int GetColumnHeight(int columnIndex)
                {
                        // Calculate current column height
                        int columnHeight = 0;
                        for(int rowIndex = 0; rowIndex < this._numberOfRowsPerColumn[columnIndex]; rowIndex++)
                        {
                                columnHeight += this._cellHeights[columnIndex, rowIndex];
                        }

                        return columnHeight;
                }

        /// <summary>
        /// Checks if legend background is selected.
        /// </summary>
        internal void SelectLegendBackground()
        {
            Common.HotRegionsList.AddHotRegion(this.Position.ToRectangleF(), this, ChartElementType.LegendArea, true);
        }

                #endregion Legend position & size methods

                #region Legend Items Fitting Methods

                /// <summary>
                /// Gets maximum number of rows in all columns.
                /// </summary>
                /// <returns>Maximum number of rows.</returns>
                private int GetMaximumNumberOfRows()
                {
                        return this.GetMaximumNumberOfRows(this._numberOfRowsPerColumn);
                }

                /// <summary>
                /// Gets maximum number of rows in all columns.
                /// </summary>
                /// <param name="rowsPerColumn">Array that stores number of rows per column.</param>
                /// <returns>Maximum number of rows.</returns>
                private int GetMaximumNumberOfRows(int[] rowsPerColumn)
                {
                        // Find column with maximum number of rows
                        int maxNumberOfColumns = 0;
                        if(rowsPerColumn != null)
                        {
                                for(int columnIndex = 0; columnIndex < rowsPerColumn.Length; columnIndex++)
                                {
                                        maxNumberOfColumns = Math.Max(maxNumberOfColumns, rowsPerColumn[columnIndex]);
                                }
                        }
                        return maxNumberOfColumns;
                }

                /// <summary>
                /// Checks if specified legend will fit the specified size.
                /// </summary>
                /// <param name="graph">Chart graphics.</param>
                /// <param name="legendItemsAreaSize">Area that legend items must fit.</param>
                /// <param name="numberOfItemsToCheck">Number of items that should be fitted.</param>
                /// <param name="fontSizeReducedBy">Number of points the standard legend font is reduced by auto-fitting algorithm.</param>
                /// <param name="numberOfColumns">Legend column number.</param>
                /// <param name="numberOfRowsPerColumn">Array of number of rows per column.</param>
                /// <param name="subColumnSizes">Returns array of sub-column size.</param>
                /// <param name="cellHeights">Returns array of cell heights.</param>
                /// <param name="horizontalSpaceLeft">Returns horizontal space left.</param>
                /// <param name="verticalSpaceLeft">Returns vertical space left.</param>
                /// <returns>True if items fit.</returns>
                private bool CheckLegendItemsFit(
                        ChartGraphics graph, 
                        Size legendItemsAreaSize,
                        int numberOfItemsToCheck,
                        int fontSizeReducedBy,
                        int numberOfColumns,
                        int[] numberOfRowsPerColumn,
                        out int[,] subColumnSizes,
                        out int[,] cellHeights,
                        out int horizontalSpaceLeft,
                        out int verticalSpaceLeft)
                {
                        bool fitFlag = true;

                        // Initialize output values
                        horizontalSpaceLeft = 0;
                        verticalSpaceLeft = 0;

                        // Use current legend item count if number of items to check is not specified
                        if(numberOfItemsToCheck < 0)
                        {
                                numberOfItemsToCheck = this.legendItems.Count;
                        }

                        // Calculate how many sub-columns (cells) this legend has
                        int numberOfSubColumns = this.GetNumberOfCells();

                        // Each column may have its own number of rows. Calculate the maximum number of rows.
                        int maxNumberOfRows = this.GetMaximumNumberOfRows(numberOfRowsPerColumn);

                        // Create multidimensional arrays that will be holding the widths and heightsof all 
                        // individual cells. First dimension will be the legend column index, second dimension 
                        // is row index and the third is sub-column (cell) index.
                        int[,,] cellWidths = new int[numberOfColumns, maxNumberOfRows, numberOfSubColumns];
                        cellHeights = new int[numberOfColumns, maxNumberOfRows];


                        //*************************************************************************
                        //** Measure legend font single character
                        //*************************************************************************
                        this.singleWCharacterSize =  graph.MeasureStringAbs("W", (this.autofitFont == null) ? this.Font : this.autofitFont);
                        Size doubleCharacterSize =  graph.MeasureStringAbs("WW", (this.autofitFont == null) ? this.Font : this.autofitFont);
                        this.singleWCharacterSize.Width = doubleCharacterSize.Width - this.singleWCharacterSize.Width;


                        //*************************************************************************
                        //** Iterate through all legend items and measure each individual cell
                        //*************************************************************************
                        int currentColumn = 0;
                        int currentRow = 0;
                        for(int legendItemIndex = 0; legendItemIndex < numberOfItemsToCheck; legendItemIndex++)
                        {
                                LegendItem legendItem = this.legendItems[legendItemIndex];

                                // Iterate through legend item cells
                                int numberOfCellsToSkip = 0;
                                for(int cellIndex = 0; cellIndex < legendItem.Cells.Count; cellIndex++)
                                {
                                        // Get legend cell
                                        LegendCell legendCell = legendItem.Cells[cellIndex];

                                        // Get assocated legend column object (may be NULL)
                                        LegendCellColumn legendColumn = null;
                                        if(cellIndex < this.CellColumns.Count)
                                        {
                                                legendColumn = this.CellColumns[cellIndex];
                                        }

                                        // Check if current cell should be skipped becuse it's overlapped 
                                        // by the previous sell that uses CellSpan.
                                        if(numberOfCellsToSkip > 0)
                                        {
                                                // Put size (-1) for the cells that follow a cell using ColumnSpan
                                                cellWidths[currentColumn, currentRow, cellIndex] = -1;
                                                --numberOfCellsToSkip;
                                                continue;
                                        }

                                        // Check if current cell uses CellSpan
                                        if(legendCell.CellSpan > 1)
                                        {
                                                numberOfCellsToSkip = legendCell.CellSpan - 1;
                                        }

                                        // Measure cell and store the value in the array
                                        Size cellSize = legendCell.MeasureCell(
                                                graph, 
                                                fontSizeReducedBy,
                                                (this.autofitFont == null) ? this.Font : this.autofitFont,
                                                this.singleWCharacterSize);

                                        // Check for column maximum/minimum cell width restrictions
                                        if(legendColumn != null)
                                        {
                                                if(legendColumn.MinimumWidth >= 0)
                                                {
                                                        cellSize.Width = (int)Math.Max(cellSize.Width, legendColumn.MinimumWidth * singleWCharacterSize.Width / 100f);
                                                }
                                                if(legendColumn.MaximumWidth >= 0)
                                                {
                                                        cellSize.Width = (int)Math.Min(cellSize.Width, legendColumn.MaximumWidth * singleWCharacterSize.Width / 100f);
                                                }
                                        }

                                        // Store cell size in arrays
                                        cellWidths[currentColumn, currentRow, cellIndex] = cellSize.Width;
                                        if(cellIndex == 0)
                                        {
                                                cellHeights[currentColumn, currentRow] = cellSize.Height;
                                        }
                                        else
                                        {
                                                cellHeights[currentColumn, currentRow] = 
                                                        Math.Max(cellHeights[currentColumn, currentRow], cellSize.Height);
                                        }
                                }

                                // Advance to the next row/column. Break if number of legend items exceed
                                // number of availabale rows/columns.
                                ++currentRow;
                                if(currentRow >= numberOfRowsPerColumn[currentColumn])
                                {
                                        ++currentColumn;
                                        currentRow = 0;
                                        if(currentColumn >= numberOfColumns)
                                        {
                                                // Check if we were able to fit all the items
                                                if(legendItemIndex < numberOfItemsToCheck - 1)
                                                {
                                                        fitFlag = false;
                                                }
                                                break;
                                        }
                                }
                        }

                        //*************************************************************************
                        //** For each sub-column get the maximum cell width
                        //*************************************************************************
                        subColumnSizes = new int[numberOfColumns, numberOfSubColumns];
                        bool secondIterationRequired = false;
                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)
                        {
                                for(int currentSubColumn = 0; currentSubColumn < numberOfSubColumns; currentSubColumn++)
                                {
                                        int width = 0;
                                        for(currentRow = 0; currentRow < numberOfRowsPerColumn[currentColumn]; currentRow++)
                                        {
                                                // Get current cell size
                                                int cellWidth = cellWidths[currentColumn, currentRow, currentSubColumn];

                                                // Skip overlapped cells and cells that use ColumnSpan during the 
                                                // first iteration. Their size will be determined during the 
                                                // second iteration.
                                                if(cellWidth < 0)
                                                {
                                                        secondIterationRequired = true;
                                                        continue;
                                                }
                                                if(currentSubColumn + 1 < numberOfSubColumns)
                                                {
                                                        int nextCellWidth = cellWidths[currentColumn, currentRow, currentSubColumn + 1];
                                                        if(nextCellWidth < 0)
                                                        {
                                                                continue;
                                                        }
                                                }

                                                // Get maximum width
                                                width = Math.Max(width, cellWidth );
                                        }

                                        // Store maximum width in the array
                                        subColumnSizes[currentColumn, currentSubColumn] = width;
                                }
                        }

                        //*************************************************************************
                        //** If leagend header text is used check if it fits into the currenly
                        //** calculated sub-column sizes.
                        //*************************************************************************

                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)
                        {
                                for(int currentSubColumn = 0; currentSubColumn < numberOfSubColumns; currentSubColumn++)
                                {
                                        if(currentSubColumn < this.CellColumns.Count)
                                        {
                                                LegendCellColumn legendColumn = this.CellColumns[currentSubColumn];
                                                if(legendColumn.HeaderText.Length > 0)
                                                {
                                                        // Note that extra "I" character added to add more horizontal spacing
                                                        Size headerTextSize =  graph.MeasureStringAbs(legendColumn.HeaderText + "I", legendColumn.HeaderFont);
                                                        if(headerTextSize.Width > subColumnSizes[currentColumn, currentSubColumn])
                                                        {
                                                                // Set new width
                                                                subColumnSizes[currentColumn, currentSubColumn] = headerTextSize.Width;

                                                                // Check for column maximum/minimum cell width restrictions
                                                                if(legendColumn.MinimumWidth >= 0)
                                                                {
                                                                        subColumnSizes[currentColumn, currentSubColumn] = 
                                                                                (int)Math.Max(subColumnSizes[currentColumn, currentSubColumn], legendColumn.MinimumWidth * singleWCharacterSize.Width / 100f);
                                                                }
                                                                if(legendColumn.MaximumWidth >= 0)
                                                                {
                                                                        subColumnSizes[currentColumn, currentSubColumn] = 
                                                                                (int)Math.Min(subColumnSizes[currentColumn, currentSubColumn], legendColumn.MaximumWidth * singleWCharacterSize.Width / 100f);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        //*************************************************************************
                        //** Adjust width of the cells to fit cell content displayed across 
                        //** several cells (CellSpanning).
                        //*************************************************************************
                        if(secondIterationRequired)
                        {
                                for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)
                                {
                                        for(int currentSubColumn = 0; currentSubColumn < numberOfSubColumns; currentSubColumn++)
                                        {
                                                for(currentRow = 0; currentRow < numberOfRowsPerColumn[currentColumn]; currentRow++)
                                                {
                                                        // Get current cell size
                                                        int cellWidth = cellWidths[currentColumn, currentRow, currentSubColumn];

                                                        // Second iteration used to adjust width of the cells that are used to
                                                        // draw content across several horizontal cells (CellSpanning)
                                                        // Check if current cell will be spanned to the next ones
                                                        int cellSpan = 0;
                                                        while(currentSubColumn + cellSpan + 1 < numberOfSubColumns)
                                                        {
                                                                int nextCellWidth = cellWidths[currentColumn, currentRow, currentSubColumn + cellSpan + 1];
                                                                if(nextCellWidth >= 0)
                                                                {
                                                                        break;  
                                                                }
                                                                ++cellSpan;
                                                        }
                                                        

                                                        // Cell span was detected
                                                        if(cellSpan > 0)
                                                        {
                                                                // Calculate total width of current cell and all overlapped cells
                                                                int spanWidth = 0;
                                                                for(int index = 0; index <= cellSpan; index++)
                                                                {
                                                                        spanWidth += subColumnSizes[currentColumn, currentSubColumn + index];
                                                                }

                                                                // Check if current cell fits into the cell span
                                                                if(cellWidth > spanWidth)
                                                                {
                                                                        // Adjust last span cell width to fit all curent cell content
                                                                        subColumnSizes[currentColumn, currentSubColumn + cellSpan] += cellWidth - spanWidth;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                

                        //*************************************************************************
                        //** Check if equally spaced legend columns are used
                        //*************************************************************************
                        if(this.IsEquallySpacedItems)
                        {
                                // Makre sure that same sub-colimn width are used in all columns
                                for(int currentSubColumn = 0; currentSubColumn < numberOfSubColumns; currentSubColumn++)
                                {
                                        int width = 0;
                                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)        
                                        {
                                                width = Math.Max(width, subColumnSizes[currentColumn, currentSubColumn]);
                                        }

                                        // Set new sub-column width for each column
                                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)        
                                        {
                                                subColumnSizes[currentColumn, currentSubColumn] = width;
                                        }
                                }
                        }

                        //*************************************************************************
                        //** Calculate total width and height occupied by all cells
                        //*************************************************************************
                        int totalWidth = 0;
                        int totalTableColumnSpacingWidth = 0;
                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)        
                        {
                                // Add up all sub-columns
                                for(int currentSubColumn = 0; currentSubColumn < numberOfSubColumns; currentSubColumn++)
                                {
                                        totalWidth += subColumnSizes[currentColumn, currentSubColumn];
                                }

                                // Add spacer between columns
                                if(currentColumn < numberOfColumns - 1)
                                {
                                        totalTableColumnSpacingWidth += this.GetSeparatorSize(this.ItemColumnSeparator).Width;
                                }
                        }

                        int totalHeight = 0;
                        for(currentColumn = 0; currentColumn < numberOfColumns; currentColumn++)        
                        {
                                int columnHeight = 0;
                                for(currentRow = 0; currentRow < numberOfRowsPerColumn[currentColumn]; currentRow++)
                                {
                                        columnHeight += cellHeights[currentColumn, currentRow];
                                }

                                totalHeight = Math.Max(totalHeight, columnHeight);
                        }

                        //*************************************************************************
                        //** Check if everything fits
                        //*************************************************************************
                        horizontalSpaceLeft = legendItemsAreaSize.Width - totalWidth - totalTableColumnSpacingWidth;
                        if(horizontalSpaceLeft < 0)
                        {
                                fitFlag = false;
                        }
                        
                        verticalSpaceLeft = legendItemsAreaSize.Height - totalHeight;
                        if(verticalSpaceLeft < 0)
                        {
                                fitFlag = false;
                        }

                        return fitFlag;
                }

                /// <summary>
                /// Gets maximum number of legend cells defined as Column objects
                /// or Cells in the custom legend items.
                /// </summary>
                /// <returns>Maximum number of cells.</returns>
                private int GetNumberOfCells()
                {
                        // Calculate cell number if it was not previously cached
                        if(this._numberOfCells < 0)
                        {
                                // Initialize with number of defined columns
                                this._numberOfCells = this.CellColumns.Count;

                                // Check if number of cells in legend items exceed number of defined columns
                                foreach(LegendItem legendItem in this.legendItems)
                                {
                                        this._numberOfCells = Math.Max(this._numberOfCells, legendItem.Cells.Count);
                                }
                        }               
                        return this._numberOfCells;
                }

                #endregion // Legend Items Fitting Methods

                #region Legend items collection filling methods

                /// <summary>
                /// Add all series legend into items collection and then
                /// add custom legend items.
                /// </summary>
                private void FillLegendItemsCollection()
                {
                        // Clear all items
                        legendItems.Clear();

                        // Check that there is no invalid legend names in the series
                        foreach(Series series in this.Common.DataManager.Series)
                        {
                if (this.Common.ChartPicture.Legends.IndexOf(series.Legend)<0)
                {
                    throw (new InvalidOperationException(SR.ExceptionLegendReferencedInSeriesNotFound(series.Name, series.Legend)));
                }
                        }

                        // Flag which indicates that series requires legend items to be reversed
                        bool    seriesWithReversedLegendItemsPresent = false;

                        // Add legend items based on the exsisting chart series
                        foreach(Series series in this.Common.DataManager.Series)
                        {
                // Check if series uses this legend
                // VSTS issue #140694 fix: support of series.Legend = "Default";
                if (this.Common.ChartPicture.Legends[series.Legend] != this)
                                {
                                        continue;
                                }

                                // Make sure series is assigned to the chart area
                                if(series.ChartArea.Length > 0)
                                {
                                        // Check if chart area name is valid
                                        bool areaNameFound = false;
                                        foreach(ChartArea area in this.Common.ChartPicture.ChartAreas)
                                        {
                                                if(area.Name == series.ChartArea)
                                                {
                                                        areaNameFound = true;
                                                        break;
                                                }
                                        }

                                        // Check if series is visible and valid chart area name was used
                                        if(series.IsVisible() && areaNameFound)
                                        {
                                                // Check if we should add all data points into the legend
                                                IChartType chartType = this.Common.ChartTypeRegistry.GetChartType(series.ChartTypeName);


                                                // Check if series legend items should be reversed
                        if (this.LegendItemOrder == LegendItemOrder.Auto)
                                                {
                                                        if(series.ChartType == SeriesChartType.StackedArea || 
                                                                series.ChartType == SeriesChartType.StackedArea100 || 
                                                                series.ChartType == SeriesChartType.Pyramid || 
                                                                series.ChartType == SeriesChartType.StackedColumn || 
                                                                series.ChartType == SeriesChartType.StackedColumn100 )
                                                        {
                                                                seriesWithReversedLegendItemsPresent = true;
                                                        }
                                                }
                                                // Add item(s) based on series points label and fore color
                                                if(chartType.DataPointsInLegend)
                                                {
                                                        // Check if data points have X values set
                                                        bool    xValuesSet = false;
                                                        foreach(DataPoint point in series.Points)
                                                        {
                                                                if(point.XValue != 0.0)
                                                                {
                                                                        xValuesSet = true;
                                                                        break;
                                                                }
                                                        }

                                                        // Add legend items for each point
                                                        int index = 0;
                                                        foreach(DataPoint point in series.Points)
                                                        {
                                                                // Do not show empty data points in the legend
                                                                if(point.IsEmpty)
                                                                {
                                                                        ++index;
                                                                        continue;
                                                                }

                                                                // Point should not be shown in the legend
                                                                if(!point.IsVisibleInLegend)
                                                                {
                                                                        ++index;
                                                                        continue;
                                                                }

                                                                // Create new legend item
                                                                LegendItem      item = new LegendItem(point.Label, point.Color, "");

                                                                // Check if series is drawn in 3D chart area
                                                                bool area3D = this.Common.Chart.ChartAreas[series.ChartArea].Area3DStyle.Enable3D;

                                                                // Set legend item appearance properties
                                                                item.SetAttributes(this.Common, series);
                                                                item.SetAttributes(point, area3D);

                                                                // Set chart image map properties
                                                                item.ToolTip = point.ReplaceKeywords(point.LegendToolTip);
#if !Microsoft_CONTROL
                                                                item.MapAreaAttributes = point.ReplaceKeywords(point.LegendMapAreaAttributes);
                                item.PostBackValue = point.ReplaceKeywords(point.LegendPostBackValue);
                                                                item.Url = point.ReplaceKeywords(point.LegendUrl);
#endif
                                                                item.Name = point.ReplaceKeywords(point.LegendText);

                                                                item.SeriesPointIndex = index++;
                                                                if(item.Name.Length == 0)
                                                                {
                                                                        item.Name = point.ReplaceKeywords((point.Label.Length > 0) ? point.Label : point.AxisLabel);
                                                                }

                                                                // If legend item name is not defined - try using the X value
                                                                if(item.Name.Length == 0 && xValuesSet)
                                                                {
                                                                        item.Name = ValueConverter.FormatValue(
                                                                                series.Chart,
                                                                                this,
                                        this.Tag,
                                                                                point.XValue, 
                                                                                "", // Do not use point label format! For Y values only! point.LabelFormat, 
                                                                                point.series.XValueType,
                                                                                ChartElementType.LegendItem);
                                                                }

                                                                // If legend item name is not defined - use index
                                                                if(item.Name.Length == 0)
                                                                {
                                                                        item.Name = "Point " + index;
                                                                }

                                                                // Add legend item cells based on predefined columns
                                                                item.AddAutomaticCells(this);
                                                                foreach(LegendCell cell in item.Cells)
                                                                {
                                                                        if(cell.Text.Length > 0)
                                                                        {
                                                                                // #LEGENDTEXT - series name
                                                                                cell.Text = cell.Text.Replace(KeywordName.LegendText, item.Name);

                                                                                // Process rest of the keywords
                                                                                cell.Text = point.ReplaceKeywords(cell.Text);
                                                                                cell.ToolTip = point.ReplaceKeywords(cell.ToolTip);
#if !Microsoft_CONTROL
                                                                                cell.Url = point.ReplaceKeywords(cell.Url);
                                                                                cell.MapAreaAttributes = point.ReplaceKeywords(cell.MapAreaAttributes);
                                        cell.PostBackValue = point.ReplaceKeywords(cell.PostBackValue);
#endif // !Microsoft_CONTROL
                                                                        }
                                                                }

                                                                legendItems.Add(item);
                                                        }
                                                }

                                                        // Add item based on series name and fore color
                                                else
                                                {
                                                        // Point should not be shown in the legend
                                                        if(!series.IsVisibleInLegend)
                                                        {
                                                                continue;
                                                        }

                                                        // Create legend item
                                                        LegendItem      item = new LegendItem(series.Name, series.Color, "");
                                                        item.SetAttributes(this.Common, series);

                                                        item.ToolTip = series.ReplaceKeywords(series.LegendToolTip);
#if !Microsoft_CONTROL
                                                        item.Url = series.ReplaceKeywords(series.LegendUrl);
                                                        item.MapAreaAttributes = series.ReplaceKeywords(series.LegendMapAreaAttributes);
                            item.PostBackValue = series.ReplaceKeywords(series.LegendPostBackValue);
#endif // !Microsoft_CONTROL

                            if (series.LegendText.Length > 0)
                                                        {
                                                                item.Name = series.ReplaceKeywords(series.LegendText);
                                                        }

                                                        // Add legend item cells based on predefined columns
                                                        item.AddAutomaticCells(this);
                                                        foreach(LegendCell cell in item.Cells)
                                                        {
                                                                if(cell.Text.Length > 0)
                                                                {
                                                                        // #LEGENDTEXT - series name
                                                                        cell.Text = cell.Text.Replace(KeywordName.LegendText, item.Name);

                                                                        // Process rest of the keywords
                                                                        cell.Text = series.ReplaceKeywords(cell.Text);
                                                                        cell.ToolTip = series.ReplaceKeywords(cell.ToolTip);
#if !Microsoft_CONTROL
                                                                        cell.Url = series.ReplaceKeywords(cell.Url);
                                                                        cell.MapAreaAttributes = series.ReplaceKeywords(cell.MapAreaAttributes);
                                    cell.PostBackValue = series.ReplaceKeywords(cell.PostBackValue);
#endif // !Microsoft_CONTROL
                                                                }
                                                        }

                            legendItems.Add(item);
                                                }
                                        }
                                }
                        }
                

                        // Check if series legend items should be reversed
            if (this.LegendItemOrder == LegendItemOrder.SameAsSeriesOrder ||
                (this.LegendItemOrder == LegendItemOrder.Auto && seriesWithReversedLegendItemsPresent))
                        {
                                // Reversed series generated legend items
                                legendItems.Reverse();
                        }


                        // Add custom items
                        foreach(LegendItem item in this._customLegends)
                        {
                                if(item.Enabled)
                                {
                                        legendItems.Add(item);
                                }
                        }

                        // Legend can't be empty at design time
                        if(legendItems.Count == 0 && this.Common != null && this.Common.Chart != null)
                        {
                                if(this.Common.Chart.IsDesignMode())
                                {
                    LegendItem item = new LegendItem(this.Name + " - " + SR.DescriptionTypeEmpty, Color.White, "");
                                        item.ImageStyle = LegendImageStyle.Line;
                                        legendItems.Add(item);
                                }
                        }

                        // Add legend item cells based on predefined columns
                        foreach(LegendItem item in this.legendItems)
                        {
                                item.AddAutomaticCells(this);
                        }

                }

                #endregion

                #region Legend painting methods

                /// <summary>
                /// Paints legend using chart graphics object.
                /// </summary>
                /// <param name="chartGraph">The graph provides drawing object to the display device. A Graphics object is associated with a specific device context.</param>
                internal void Paint(ChartGraphics chartGraph )
                {
                        // Reset some values
                        this._offset = Size.Empty;
                        this._itemColumns = 0;
                        this._horizontalSpaceLeft = 0;
                        this._verticalSpaceLeft = 0;
                        this._subColumnSizes = null;
                        this._numberOfRowsPerColumn = null;
                        this._cellHeights = null;
                        this.autofitFont = null;
                        this._autoFitFontSizeAdjustment = 0;
                        this._numberOfCells = -1;
                        this._numberOfLegendItemsToProcess = -1;

                        // Do nothing if legend disabled
                        if(!this.IsEnabled() ||
                                (this.MaximumAutoSize == 0f && this.Position.Auto))
                        {
                                return;
                        }

                        // Add all series legend into items collection and then add custom legend items
                        FillLegendItemsCollection();

                        // Clear all legend item cells information
                        foreach(LegendItem legendItem in this.legendItems)
                        {
                                foreach(LegendCell cell in legendItem.Cells)
                                {
                                        cell.ResetCache();
                                }
                        }

                        // Call a notification event, so that legend items collection can be modified by user
            this.Common.Chart.CallOnCustomizeLegend(legendItems, this.Name);

                        // Check if legend is empty
                        if(this.legendItems.Count == 0)
                        {
                                return;
                        }

                        //***********************************************************
                        //** RecalculateAxesScale legend information
                        //***********************************************************
                        this.RecalcLegendInfo(chartGraph);


                        
                        //***********************************************************
                        //** Paint legend
                        //***********************************************************

                        // Call BackPaint event
                        if( Common.ProcessModePaint )
                        {
                                // Draw legend background, border and shadow
                                chartGraph.FillRectangleRel( 
                                        chartGraph.GetRelativeRectangle(Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()))),
                                        BackColor, 
                                        BackHatchStyle, 
                                        BackImage, 
                                        BackImageWrapMode, 
                                        BackImageTransparentColor,
                                        BackImageAlignment,
                                        BackGradientStyle, 
                                        BackSecondaryColor,
                                        BorderColor, 
                                        this.GetBorderSize(), 
                                        BorderDashStyle, 
                                        ShadowColor, 
                                        ShadowOffset,
                                        PenAlignment.Inset);

                Common.Chart.CallOnPrePaint(new ChartPaintEventArgs(this, chartGraph, Common, Position));
                        }

                        if( Common.ProcessModeRegions )
                        {
                                SelectLegendBackground();
                        }

                        //***********************************************************
                        //** Draw legend header
                        //***********************************************************

                        this.DrawLegendHeader(chartGraph);

                        //***********************************************************
                        //** Draw legend title
                        //***********************************************************

                        this.DrawLegendTitle(chartGraph);

                        // Add legend title hot region
                        if( Common.ProcessModeRegions && !this._titlePosition.IsEmpty)
                        {
                                Common.HotRegionsList.AddHotRegion(chartGraph.GetRelativeRectangle(this._titlePosition), this, ChartElementType.LegendTitle, true );
                        }

                        //***********************************************************
                        //** Draw legend items
                        //***********************************************************
                        if(this._numberOfLegendItemsToProcess < 0)
                        {
                                this._numberOfLegendItemsToProcess = this.legendItems.Count;
                        }
                        for(int itemIndex = 0; itemIndex < this._numberOfLegendItemsToProcess; itemIndex++)
                        {
                                LegendItem legendItem = this.legendItems[itemIndex];

                                // Iterate through legend item cells
                                for(int cellIndex = 0; cellIndex < legendItem.Cells.Count; cellIndex++)
                                {
                                        // Get legend cell
                                        LegendCell legendCell = legendItem.Cells[cellIndex];

                                        // Paint cell
                                        legendCell.Paint(
                                                chartGraph, 
                                                this._autoFitFontSizeAdjustment,
                                                this.autofitFont,
                                                this.singleWCharacterSize);
                                }

                                // Paint legend item separator
                                if(legendItem.SeparatorType != LegendSeparatorStyle.None && 
                                        legendItem.Cells.Count > 0)
                                {
                                        // Calculate separator position
                                        Rectangle separatorPosition = Rectangle.Empty;
                                        separatorPosition.X = legendItem.Cells[0].cellPosition.Left;

                                        // Find right most cell position excluding ovelapped cells that have negative size
                                        int right = 0;
                                        for(int index = legendItem.Cells.Count - 1; index >= 0; index--)
                                        {
                                                right = legendItem.Cells[index].cellPosition.Right;
                                                if(right > 0)
                                                {
                                                        break;
                                                }
                                        }
                                        separatorPosition.Width = right - separatorPosition.X;
                                        separatorPosition.Y = legendItem.Cells[0].cellPosition.Bottom;
                                        separatorPosition.Height = this.GetSeparatorSize(legendItem.SeparatorType).Height;
                                        separatorPosition.Intersect(this._legendItemsAreaPosition);

                                        // Draw separator
                                        this.DrawSeparator(
                                                chartGraph, 
                                                legendItem.SeparatorType,
                                                legendItem.SeparatorColor, 
                                                true,
                                                separatorPosition);
                                }
                        }

                        //***********************************************************
                        //** If legend items are in multiple columns draw vertical
                        //** separator
                        //***********************************************************
                        if(this.ItemColumnSeparator != LegendSeparatorStyle.None)
                        {
                                Rectangle separatorRect = Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()));
                                separatorRect.Y += this.GetBorderSize() + this._titlePosition.Height;
                                separatorRect.Height -= 2 * this.GetBorderSize() + this._titlePosition.Height;
                                separatorRect.X += this.GetBorderSize() + this._offset.Width;
                                separatorRect.Width = this.GetSeparatorSize(this.ItemColumnSeparator).Width;
                                if(this._horizontalSpaceLeft > 0)
                                {
                                        separatorRect.X += this._horizontalSpaceLeft / 2;
                                }

                                // Check position
                                if(separatorRect.Width > 0 && separatorRect.Height > 0)
                                {
                                        // Iterate through all columns
                                        for(int columnIndex = 0; columnIndex < this._itemColumns; columnIndex++ )
                                        {
                                                // Iterate through all sub-columns
                                                int cellCount = this.GetNumberOfCells();
                                                for(int subColumnIndex = 0; subColumnIndex < cellCount; subColumnIndex++ )
                                                {
                                                        separatorRect.X += this._subColumnSizes[columnIndex, subColumnIndex];
                                                }

                                                // Draw separator if not the last column
                                                if(columnIndex < this._itemColumns - 1)
                                                {
                                                        this.DrawSeparator(chartGraph, this.ItemColumnSeparator, this.ItemColumnSeparatorColor, false, separatorRect);
                                                }

                                                // Add separator width
                                                separatorRect.X += separatorRect.Width;
                                        }
                                }
                        }

                        //***********************************************************
                        //** Draw special indicator on the bottom of the legend if 
                        //** it was truncated.
                        //***********************************************************
                        if(this._legendItemsTruncated &&
                                this._legendItemsAreaPosition.Height > this._truncatedDotsSize / 2)
                        {
                                // Calculate dots step (no more than 10 pixel)
                                int markerCount = 3;
                                int step = (this._legendItemsAreaPosition.Width / 3) / markerCount;
                                step = (int)Math.Min(step, 10);

                                // Calculate start point
                                PointF  point = new PointF(
                                        this._legendItemsAreaPosition.X + this._legendItemsAreaPosition.Width / 2 - step * (float)Math.Floor(markerCount/2f),
                                        this._legendItemsAreaPosition.Bottom + (this._truncatedDotsSize + this._offset.Height) / 2);

                                // Draw several dots at the bottom of the legend
                                for(int index = 0; index < markerCount; index++)
                                {
                                        chartGraph.DrawMarkerRel(
                                                chartGraph.GetRelativePoint(point),
                                                MarkerStyle.Circle,
                                                this._truncatedDotsSize,
                                                this.ForeColor,
                                                Color.Empty,
                                                0,
                                                string.Empty,
                                                Color.Empty,
                                                0,
                                                Color.Empty,
                                                RectangleF.Empty);

                                        // Shift to the right
                                        point.X += step;
                                }

                        }


                        // Call Paint event
                        if( Common.ProcessModePaint )
                        {
                Common.Chart.CallOnPostPaint(new ChartPaintEventArgs(this, chartGraph, Common, Position));
                        }
                                                
                        // Remove temporary cells from legend items
                        foreach(LegendItem legendItem in this.legendItems)
                        {
                                if(legendItem.clearTempCells)
                                {
                                        legendItem.clearTempCells = false;
                                        legendItem.Cells.Clear();
                                }
                        }

                }

                #endregion 

                #region Legend properties

                /// <summary>
                /// Gets or sets the name of the legend.
                /// </summary>
                [
                SRCategory("CategoryAttributeMisc"),
                Bindable(true),
                SRDescription("DescriptionAttributeLegend_Name"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                ]
                public override string Name
                {
                        get
                        {
                                return base.Name;
                        }
                        set
                        {
                base.Name = value;
                        }
                }

                /// <summary>
                /// Gets or sets the name of the chart area where the legend
        /// should be docked.
                /// </summary>
                [
                SRCategory("CategoryAttributeDocking"),
                Bindable(true),
        DefaultValue(Constants.NotSetValue),
                SRDescription("DescriptionAttributeLegend_DockToChartArea"),
        TypeConverter(typeof(LegendAreaNameConverter)),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                ]
                public string DockedToChartArea
                {
                        get
                        {
                                return _dockedToChartArea;
                        }
                        set
                        {
                                if(value != _dockedToChartArea)
                                {
                                        if (String.IsNullOrEmpty(value))
                                        {
                        _dockedToChartArea = Constants.NotSetValue;
                                        }
                                        else
                                        {
                        if (Chart != null && Chart.ChartAreas != null)
                        {
                            Chart.ChartAreas.VerifyNameReference(value);
                        }
                                                _dockedToChartArea = value;
                                        }
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
                /// Gets or sets a property which indicates whether 
        /// the legend is docked inside the chart area.  
        /// This property is only available when DockedToChartArea is set.
                /// </summary>
                [
        SRCategory("CategoryAttributeDocking"),
                Bindable(true),
                DefaultValue(true),
                SRDescription("DescriptionAttributeLegend_DockInsideChartArea"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                ]
                public bool IsDockedInsideChartArea
                {
                        get
                        {
                                return _isDockedInsideChartArea;
                        }
                        set
                        {
                                if(value != _isDockedInsideChartArea)
                                {
                                        _isDockedInsideChartArea = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the position of the legend.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                SRDescription("DescriptionAttributeLegend_Position"),
#if Microsoft_CONTROL
                DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
#else
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
                NotifyParentPropertyAttribute(true),
                TypeConverter(typeof(ElementPositionConverter)),
                SerializationVisibilityAttribute(SerializationVisibility.Element)
                ]
                public ElementPosition Position
                {
                        get
                        {       
                                // Serialize only position values if Auto set to false
                if (this.Common != null && this.Common.Chart != null && this.Common.Chart.serializationStatus == SerializationStatus.Saving)
                                {
                                        if(_position.Auto)
                                        {
                                                return new ElementPosition();   
                                        }
                                        else
                                        {
                                                ElementPosition newPosition = new ElementPosition();
#if Microsoft_CONTROL
                                                newPosition.Auto = false;
#else
                                                newPosition.Auto = true;
#endif
                                                newPosition.SetPositionNoAuto(_position.X, _position.Y, _position.Width, _position.Height);
                                                return newPosition;
                                        }
                                }
                                return _position;
                        }
                        set
                        {
                                _position = value;
                                this.Invalidate(false);
                        }
                }

        /// <summary>
        /// Determoines if this position should be serialized.
        /// </summary>
        /// <returns></returns>
        internal bool ShouldSerializePosition()
        {
            return !this.Position.Auto;
        }


                /// <summary>
                /// Gets or sets a property which indicates whether 
        /// all legend items are equally spaced.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(false),
                SRDescription("DescriptionAttributeLegend_EquallySpacedItems"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public bool IsEquallySpacedItems
                {
                        get
                        {
                                return _isEquallySpacedItems;
                        }
                        set
                        {
                                _isEquallySpacedItems = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets a flag which indicates whether the legend is enabled.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(true),
                SRDescription("DescriptionAttributeLegend_Enabled"),
                NotifyParentPropertyAttribute(true),
                ParenthesizePropertyNameAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public bool Enabled
                {
                        get
                        {
                                return _enabled;
                        }
                        set
                        {
                                _enabled = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
        /// Gets or sets a value that indicates if legend text is automatically sized.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(true),
                SRDescription("DescriptionAttributeLegend_AutoFitText"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public bool IsTextAutoFit
                {
                        get
                        {
                                return _isTextAutoFit;
                        }
                        set
                        {
                                _isTextAutoFit = value;

                                if(_isTextAutoFit)
                                {
                                        // Reset the font size to "8"
                                        // Use current font family name ans style if possible.
                                        if(_font != null)
                                        {
                        _font = _fontCache.GetFont(_font.FontFamily, 8, _font.Style); ;
                                        }
                                        else
                                        {
                                                _font = _fontCache.DefaultFont;
                                        }
                                }

                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the legend style.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(LegendStyle.Table),
                SRDescription("DescriptionAttributeLegend_LegendStyle"),
                NotifyParentPropertyAttribute(true),
                ParenthesizePropertyNameAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public LegendStyle LegendStyle
                {
                        get
                        {
                                return _legendStyle;
                        }
                        set
                        {
                                _legendStyle = value;
                                this.Invalidate(false);
                        }
                }


                /// <summary>
        /// Gets or sets the minimum font size that can be used by the legend text's auto-fitting algorithm. 
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(7),
                SRDescription("DescriptionAttributeLegend_AutoFitMinFontSize"),
                ]
                public int AutoFitMinFontSize
                {
                        get
                        {
                                return this._autoFitMinFontSize;
                        }
                        set
                        {
                                // Font size cannot be less than 5
                                if(value < 5)
                                {
                    throw (new InvalidOperationException(SR.ExceptionLegendAutoFitMinFontSizeInvalid));
                                }

                                this._autoFitMinFontSize = value;
                                this.Invalidate(false);
                        }
                }

        /// <summary>
        /// Gets or sets the maximum size (in percentage) of the legend used in the automatic layout algorithm.
        /// </summary>
        /// <remarks>
        /// If the legend is docked to the left or right, this property determines the maximum width of the legend, measured as a percentage.
        /// If the legend is docked to the top or bottom, this property determines the maximum height of the legend, measured as a percentage.
        /// </remarks>
                [
                SRCategory("CategoryAttributeDocking"),
                DefaultValue(50f),
                SRDescription("DescriptionAttributeLegend_MaxAutoSize"),
                ]
                public float MaximumAutoSize
                {
                        get
                        {
                return this._maximumLegendAutoSize;
                        }
                        set
                        {
                                if(value < 0f || value > 100f)
                                {
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionLegendMaximumAutoSizeInvalid));
                                }
                this._maximumLegendAutoSize = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets a collection of legend columns.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                SRDescription("DescriptionAttributeLegend_CellColumns"),
#if Microsoft_CONTROL
                DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
#else
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
        Editor(Editors.LegendCellColumnCollectionEditor.Editor, Editors.LegendCellColumnCollectionEditor.Base),
                ]
                public LegendCellColumnCollection CellColumns
                {
                        get
                        {
                                return this._cellColumns;
                        }
                }

                /// <summary>
                /// Gets the legend table style.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(LegendTableStyle.Auto),
                SRDescription("DescriptionAttributeLegend_TableStyle"),
                NotifyParentPropertyAttribute(true),
                ParenthesizePropertyNameAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public LegendTableStyle TableStyle
                {
                        get
                        {
                                return this._legendTableStyle;
                        }
                        set
                        {
                                this._legendTableStyle = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets the legend header separator style.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                DefaultValue(typeof(LegendSeparatorStyle), "None"),
                SRDescription("DescriptionAttributeLegend_HeaderSeparator"),
                ]
                public LegendSeparatorStyle HeaderSeparator
                {
                        get
                        {
                                return this._headerSeparator;
                        }
                        set
                        {
                                if(value != this._headerSeparator)
                                {
                                        this._headerSeparator = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
                /// Gets or sets the color of the legend header separator.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                DefaultValue(typeof(Color), "Black"),
                SRDescription("DescriptionAttributeLegend_HeaderSeparatorColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color HeaderSeparatorColor
                {
                        get
                        {
                                return this._headerSeparatorColor;
                        }
                        set
                        {
                                if(value != this._headerSeparatorColor)
                                {
                                        this._headerSeparatorColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the separator style of the legend table columns.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                DefaultValue(typeof(LegendSeparatorStyle), "None"),
                SRDescription("DescriptionAttributeLegend_ItemColumnSeparator"),
                ]
                public LegendSeparatorStyle ItemColumnSeparator
                {
                        get
                        {
                                return this._itemColumnSeparator;
                        }
                        set
                        {
                                if(value != this._itemColumnSeparator)
                                {
                                        this._itemColumnSeparator = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the color of the separator of the legend table columns.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                DefaultValue(typeof(Color), "Black"),
                SRDescription("DescriptionAttributeLegend_ItemColumnSeparatorColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color ItemColumnSeparatorColor
                {
                        get
                        {
                                return this._itemColumnSeparatorColor;
                        }
                        set
                        {
                                if(value != this._itemColumnSeparatorColor)
                                {
                                        this._itemColumnSeparatorColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }


                /// <summary>
                /// Gets or sets the legend table column spacing, as a percentage of the legend text font.
                /// </summary>
                [
                SRCategory("CategoryAttributeCellColumns"),
                DefaultValue(50),
                SRDescription("DescriptionAttributeLegend_ItemColumnSpacing"),
                ]
                public int ItemColumnSpacing
                {
                        get
                        {
                                return this._itemColumnSpacing;
                        }
                        set
                        {
                                if(value != this._itemColumnSpacing)
                                {
                                        if(value < 0)
                                        {
                        throw (new ArgumentOutOfRangeException("value", SR.ExceptionLegendColumnSpacingInvalid));
                                        }
                                        this._itemColumnSpacing = value;
                                        this.Invalidate(false);
                                }
                        }
                }



                /// <summary>
                /// Gets or sets the legend background color.
                /// </summary>
                [
                DefaultValue(typeof(Color), ""),
        SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
        SRDescription("DescriptionAttributeBackColor"),
                NotifyParentPropertyAttribute(true),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Color BackColor
                {
                        get
                        {
                                return _backColor;
                        }
                        set
                        {
                                _backColor = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the legend border color.
                /// </summary>
                [
                DefaultValue(typeof(Color), ""),
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
        SRDescription("DescriptionAttributeBorderColor"),
                NotifyParentPropertyAttribute(true),
        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;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the legend border style.
                /// </summary>
                [

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

                /// <summary>
                /// Gets or sets the legend border width.
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(1),
        SRDescription("DescriptionAttributeBorderWidth"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public int BorderWidth
                {
                        get
                        {
                                return _borderWidth;
                        }
                        set
                        {
                                if(value < 0)
                                {
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionLegendBorderWidthIsNegative));
                                }
                                _borderWidth = value;
                                this.Invalidate(false);
                        }
                }
                
                /// <summary>
                /// Gets or sets the legend 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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the legend 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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets a color which will be replaced with a transparent color while drawing the background image.
                /// </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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the background image alignment used for the unscaled 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 _backImageAlignment;
                        }
                        set
                        {
                                _backImageAlignment = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets background gradient style of the legend.
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(GradientStyle.None),
                NotifyParentPropertyAttribute(true),
        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;
                                this.Invalidate(true);
                        }
                }

        /// <summary>
        /// Gets or sets the secondary background color.
        /// <seealso cref="BackColor"/>
        /// <seealso cref="BackHatchStyle"/>
        /// <seealso cref="BackGradientStyle"/>
        /// </summary>
        /// <value>
        /// A <see cref="Color"/> value used for the secondary color of background with 
        /// hatching or gradient fill.
        /// </value>
        /// <remarks>
        /// This color is used with <see cref="BackColor"/> when <see cref="BackHatchStyle"/> or
        /// <see cref="BackGradientStyle"/> are used.
        /// </remarks>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
                NotifyParentPropertyAttribute(true),
        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
                        {
                                _backSecondaryColor = value;
                                this.Invalidate(true);
                        }
                }

        /// <summary>
        /// Gets or sets the background hatch style.
        /// <seealso cref="BackSecondaryColor"/>
        /// <seealso cref="BackColor"/>
        /// <seealso cref="BackGradientStyle"/>
        /// </summary>
        /// <value>
        /// A <see cref="ChartHatchStyle"/> value used for the background.
        /// </value>
        /// <remarks>
        /// Two colors are used to draw the hatching, <see cref="BackColor"/> and <see cref="BackSecondaryColor"/>.
        /// </remarks>
                [

        SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(ChartHatchStyle.None),
                NotifyParentPropertyAttribute(true),
        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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the font of the legend text.
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Font), "Microsoft Sans Serif, 8pt"),
                SRDescription("DescriptionAttributeLegend_Font"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Font Font
                {
                        get
                        {
                                return _font;
                        }
                        set
                        {
                                this.IsTextAutoFit = false;

                                _font = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the color of the legend text.
                /// </summary>
                [

                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "Black"),
        SRDescription("DescriptionAttributeLegendFontColor"),
                NotifyParentPropertyAttribute(true),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Color ForeColor
                {
                        get
                        {
                                return _foreColor;
                        }
                        set
                        {
                                _foreColor = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the text alignment.
                /// </summary>
                [
                SRCategory("CategoryAttributeDocking"),
                Bindable(true),
                DefaultValue(StringAlignment.Near),
                SRDescription("DescriptionAttributeLegend_Alignment"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public StringAlignment Alignment
                {
                        get
                        {
                                return _legendAlignment;
                        }
                        set
                        {
                                _legendAlignment = value;
                                this.Invalidate(false);
                        }
                }
                
                /// <summary>
                /// Gets or sets the property that specifies where the legend docks.
                /// </summary>
                [
        SRCategory("CategoryAttributeDocking"),
                Bindable(true),
                DefaultValue(Docking.Right),
                SRDescription("DescriptionAttributeLegend_Docking"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Docking Docking
                {
                        get
                        {
                                return _legendDocking;
                        }
                        set
                        {
                                _legendDocking = value;
                                this.Invalidate(false);
                        }
                }

        /// <summary>
        /// Gets or sets the offset between the legend and its shadow.
        /// <seealso cref="ShadowColor"/>
        /// </summary>
        /// <value>
        /// An integer value that represents the offset between the legend and its shadow.
        /// </value>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(0),
        SRDescription("DescriptionAttributeShadowOffset"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public int ShadowOffset
                {
                        get
                        {
                                return _shadowOffset;
                        }
                        set
                        {
                                _shadowOffset = value;
                                this.Invalidate(false);
                        }
                }

        /// <summary>
        /// Gets or sets the color of a legend's shadow.
        /// <seealso cref="ShadowOffset"/>
        /// </summary>
        /// <value>
        /// A <see cref="Color"/> value used to draw a legend's shadow.
        /// </value>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "128, 0, 0, 0"),
        SRDescription("DescriptionAttributeShadowColor"),
                NotifyParentPropertyAttribute(true),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Color ShadowColor
                {
                        get
                        {
                                return _shadowColor;
                        }
                        set
                        {
                                _shadowColor = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the name of the chart area name inside which the legend is drawn.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Browsable(false),
                Bindable(false),
        DefaultValue(Constants.NotSetValue),
                NotifyParentPropertyAttribute(true),
                SRDescription("DescriptionAttributeLegend_InsideChartArea"),
                EditorBrowsableAttribute(EditorBrowsableState.Never),
                DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content),
                SerializationVisibilityAttribute(SerializationVisibility.Hidden),
                TypeConverter(typeof(LegendAreaNameConverter))
                ]
                public string InsideChartArea
                {
                        get
                        {
                                if(this.Common != null && 
                                        this.Common.Chart != null &&
                                        this.Common.Chart.serializing)
                                {
                                        return "NotSet";
                                }
                                return this.DockedToChartArea;
                        }
                        set
                        {
                                if(value.Length == 0)
                                {
                    this.DockedToChartArea = Constants.NotSetValue;
                                }
                                else
                                {
                                        this.DockedToChartArea = value;
                                }
                                this.Invalidate(false);
                        }
                }


                /// <summary>
                /// Gets the custom legend items.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                NotifyParentPropertyAttribute(true),
                SRDescription("DescriptionAttributeLegend_CustomItems"),
#if Microsoft_CONTROL
                DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
#else
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
        Editor(Editors.LegendItemCollectionEditor.Editor, Editors.LegendItemCollectionEditor.Base),
                ]
                public LegendItemsCollection CustomItems
                {
                        get
                        {
                                return _customLegends;
                        }
                }



                /// <summary>
                /// Gets or sets a property that defines the preferred number of characters in a line of the legend text.
                /// </summary>
                /// <remarks>
                /// When legend text exceeds the value defined in the <b>TextWrapThreshold</b> property, it will be
                /// automatically wrapped on the next whitespace. Text will not be wrapped if there is no whitespace
                /// characters in the text. Set this property to zero to disable the feature.
                /// </remarks>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(25),
                SRDescription("DescriptionAttributeLegend_TextWrapThreshold"),
                ]
                public int TextWrapThreshold
                {
                        get
                        {
                                return this._textWrapThreshold;
                        }
                        set
                        {
                                if(value != this._textWrapThreshold)
                                {
                                        if(value < 0)
                                        {
                        throw (new ArgumentException(SR.ExceptionTextThresholdIsNegative, "value"));
                                        }
                                        this._textWrapThreshold = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
                /// Gets or sets a property that specifies the order that legend items are shown. This property only affects 
                /// legend items automatically added for the chart series and has no effect on custom legend items.
                /// </summary>
                /// <remarks>
                /// When the <b>LegendItemOrder</b> property is set to <b>Auto</b>, the legend will automatically be reversed 
                /// if StackedColumn, StackedColumn100, StackedArea or StackedArea100 chart types are used.
                /// </remarks>
                [
                SRCategory("CategoryAttributeAppearance"),
        DefaultValue(LegendItemOrder.Auto),
                SRDescription("DescriptionAttributeLegend_Reversed"),
                ]
        public LegendItemOrder LegendItemOrder
                {
                        get
                        {
                                return this._legendItemOrder;
                        }
                        set
                        {
                                if(value != this._legendItemOrder)
                                {
                                        this._legendItemOrder = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
                /// Gets or sets a flag which indicates whether 
        /// legend rows should be drawn with interlaced background color.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(false),
                SRDescription("DescriptionAttributeLegend_InterlacedRows"),
                ]
                public bool InterlacedRows
                {
                        get
                        {
                                return this._interlacedRows;
                        }
                        set
                        {
                                if(value != this._interlacedRows)
                                {
                                        this._interlacedRows = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the legend interlaced row's background color. Only applicable if interlaced rows are used. 
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(typeof(Color), ""),
                SRDescription("DescriptionAttributeLegend_InterlacedRowsColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color InterlacedRowsColor
                {
                        get
                        {
                                return this._interlacedRowsColor;
                        }
                        set
                        {
                                if(value != this._interlacedRowsColor)
                                {
                                        this._interlacedRowsColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                #endregion

                #region Legend Title Properties

                /// <summary>
                /// Gets or sets the title text of the legend.
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(""),
                SRDescription("DescriptionAttributeLegend_Title"),
                ]
                public string Title
                {
                        get
                        {
                                return this._title;
                        }
                        set
                        {
                                if(value != this._title)
                                {
                                        this._title = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the text color of the legend title.
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(typeof(Color), "Black"),
                SRDescription("DescriptionAttributeLegend_TitleColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color TitleForeColor
                {
                        get
                        {
                                return this._titleForeColor;
                        }
                        set
                        {
                                if(value != this._titleForeColor)
                                {
                                        this._titleForeColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the background color of the legend title. 
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeTitleBackColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color TitleBackColor
                {
                        get
                        {
                                return this._titleBackColor;
                        }
                        set
                        {
                                if(value != this._titleBackColor)
                                {
                                        this._titleBackColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the font of the legend title. 
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
        DefaultValue(typeof(Font), "Microsoft Sans Serif, 8pt, style=Bold"),
        SRDescription("DescriptionAttributeTitleFont"),
                ]
                public Font TitleFont
                {
                        get
                        {
                                return this._titleFont;
                        }
                        set
                        {
                                if(value != this._titleFont)
                                {
                                        this._titleFont = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the text alignment of the legend title.
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(typeof(StringAlignment), "Center"),
                SRDescription("DescriptionAttributeLegend_TitleAlignment"),
                ]
                public StringAlignment TitleAlignment
                {
                        get
                        {
                                return this._titleAlignment;
                        }
                        set
                        {
                                if(value != this._titleAlignment)
                                {
                                        this._titleAlignment = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the separator style of the legend title.
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(typeof(LegendSeparatorStyle), "None"),
                SRDescription("DescriptionAttributeLegend_TitleSeparator"),
                ]
                public LegendSeparatorStyle TitleSeparator
                {
                        get
                        {
                                return this._titleSeparator;
                        }
                        set
                        {
                                if(value != this._titleSeparator)
                                {
                                        this._titleSeparator = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the separator color of the legend title.
                /// </summary>
                [
                SRCategory("CategoryAttributeTitle"),
                DefaultValue(typeof(Color), "Black"),
                SRDescription("DescriptionAttributeLegend_TitleSeparatorColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color TitleSeparatorColor
                {
                        get
                        {
                                return this._titleSeparatorColor;
                        }
                        set
                        {
                                if(value != this._titleSeparatorColor)
                                {
                                        this._titleSeparatorColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }



                #endregion // Legend Title Properties

                #region Legent Title and Header Helper methods

                /// <summary>
                /// Gets legend title size in relative coordinates.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="titleMaxSize">Maximum possible legend title size.</param>
                /// <returns>Legend yitle size.</returns>
                private Size GetTitleSize(ChartGraphics chartGraph, Size titleMaxSize)
                {
                        Size titleSize = Size.Empty;
                        if(this.Title.Length > 0)
                        {
                                // Adjust available space
                                titleMaxSize.Width -= this.GetBorderSize() * 2 + this._offset.Width;

                                // Measure title text size
                                titleSize = chartGraph.MeasureStringAbs(
                                        this.Title.Replace("\\n", "\n"), 
                                        this.TitleFont,
                                        titleMaxSize,
                                        StringFormat.GenericTypographic);

                                // Add text spacing
                                titleSize.Height += this._offset.Height;
                                titleSize.Width += this._offset.Width;

                                // Add space required for the title separator
                                titleSize.Height += this.GetSeparatorSize(this.TitleSeparator).Height;
                        }

                        return titleSize;
                }

                /// <summary>
                /// Gets legend header size in relative coordinates.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="legendColumn">Legend column to get the header for.</param>
                /// <returns>Legend yitle size.</returns>
                private Size GetHeaderSize(ChartGraphics chartGraph, LegendCellColumn legendColumn)
                {
                        Size headerSize = Size.Empty;
                        if(legendColumn.HeaderText.Length > 0)
                        {
                                // Measure title text size
                                headerSize = chartGraph.MeasureStringAbs(
                                        legendColumn.HeaderText.Replace("\\n", "\n") + "I", 
                                        legendColumn.HeaderFont);

                                // Add text spacing
                                headerSize.Height += this._offset.Height;
                                headerSize.Width += this._offset.Width;

                                // Add space required for the title separator
                                headerSize.Height += this.GetSeparatorSize(this.HeaderSeparator).Height;
                        }

                        return headerSize;
                }

                /// <summary>
                /// Draw Legend header.
                /// </summary>
                /// <param name="chartGraph">Chart graphics to draw the header on.</param>
                private void DrawLegendHeader(ChartGraphics chartGraph)
                {
                        // Check if header should be drawn
                        if(!this._headerPosition.IsEmpty &&
                                this._headerPosition.Width > 0 &&
                                this._headerPosition.Height > 0)
                        {
                                int prevRightLocation = -1;
                                bool redrawLegendBorder = false;

                                // Get Legend position
                                Rectangle legendPosition = Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()));
                                legendPosition.Y += /*this.offset.Height + */this.GetBorderSize();
                                legendPosition.Height -= 2 * (this._offset.Height + this.GetBorderSize());
                                legendPosition.X += this.GetBorderSize();
                                legendPosition.Width -= 2 * this.GetBorderSize();
                                if(this.GetBorderSize() > 0)
                                {
                                        ++legendPosition.Height;
                                        ++legendPosition.Width;
                                }

                                // Check if at least 1 column header has non-empty background color
                                bool    headerBackFill = false;
                                for(int subColumnIndex = 0; subColumnIndex < this.CellColumns.Count; subColumnIndex++ )
                                {
                                        LegendCellColumn legendColumn = this.CellColumns[subColumnIndex];
                                        if(!legendColumn.HeaderBackColor.IsEmpty)
                                        {
                                                headerBackFill = true;
                                        }
                                }

                                // Iterate through all columns
                                for(int columnIndex = 0; columnIndex < this._itemColumns; columnIndex++ )
                                {
                                        int columnStart = 0;
                                        int columnWidth = 0;

                                        // Iterate through all sub-columns
                                        int numberOfSubColumns = this._subColumnSizes.GetLength(1);
                                        for(int subColumnIndex = 0; subColumnIndex < numberOfSubColumns; subColumnIndex++ )
                                        {
                                                // Calculate position of the header
                                                Rectangle rect = this._headerPosition;
                                                if(_horizontalSpaceLeft > 0)
                                                {
                                                        rect.X += (int)(this._horizontalSpaceLeft / 2f);
                                                }
                                                if(prevRightLocation != -1)
                                                {
                                                        rect.X = prevRightLocation;
                                                }
                                                rect.Width = this._subColumnSizes[columnIndex, subColumnIndex];
                                                prevRightLocation = rect.Right;

                                                // Remember column start position and update width
                                                if(subColumnIndex == 0)
                                                {
                                                        columnStart = rect.Left;
                                                }
                                                columnWidth += rect.Width;

                                                // Make sure header position do not go outside of the legend
                                                rect.Intersect(legendPosition);
                                                if(rect.Width > 0 && rect.Height > 0)
                                                {
                                                        // Define fill rectangle
                                                        Rectangle fillRect = rect;

                                                        // Make sure header fill riches legend top border
                                                        if(this._titlePosition.Height <= 0)
                                                        {
                                                                fillRect.Y -= this._offset.Height;
                                                                fillRect.Height += this._offset.Height;
                                                        }

                                                        // Stretch header fill rectangle and separators when vertical 
                                                        // separator are used or if there is 1 column with header background
                                                        if( (this._itemColumns == 1 && headerBackFill) ||
                                                                this.ItemColumnSeparator != LegendSeparatorStyle.None)
                                                        {
                                                                // For the first cell in the first column stretch filling
                                                                // to the left side of the legend
                                                                if(columnIndex == 0 && subColumnIndex == 0)
                                                                {
                                                                        int newX = legendPosition.X;
                                                                        columnWidth += columnStart - newX;
                                                                        columnStart = newX;
                                                                        fillRect.Width += fillRect.X - legendPosition.X;
                                                                        fillRect.X = newX;
                                                                }

                                                                // For the last cell in the last column stretch filling
                                                                // to the right side of the legend
                                                                if(columnIndex == (this._itemColumns - 1) && 
                                                                        subColumnIndex == (numberOfSubColumns - 1) )
                                                                {
                                                                        columnWidth += legendPosition.Right - fillRect.Right + 1;
                                                                        fillRect.Width += legendPosition.Right - fillRect.Right + 1;
                                                                }

                                                                // For the first cell of any column except the first one
                                                                // make sure we also fill the item column spacing
                                                                if(columnIndex != 0 && subColumnIndex == 0)
                                                                {
                                                                        columnWidth += this._itemColumnSpacingRel / 2;
                                                                        columnStart -= this._itemColumnSpacingRel / 2;
                                                                        fillRect.Width += this._itemColumnSpacingRel / 2;
                                                                        fillRect.X -= this._itemColumnSpacingRel / 2;
                                                                }

                                                                // For the last cell in all columns except the last one 
                                                                // make sure we also fill the item column spacing
                                                                if(columnIndex != (this._itemColumns - 1) && 
                                                                        subColumnIndex == (numberOfSubColumns - 1) )
                                                                {
                                                                        columnWidth += this._itemColumnSpacingRel / 2;
                                                                        fillRect.Width += this._itemColumnSpacingRel / 2;
                                                                }
                                                        }

                                                        if(subColumnIndex < this.CellColumns.Count)
                                                        {
                                                                // Draw header background
                                                                LegendCellColumn legendColumn = this.CellColumns[subColumnIndex];
                                                                if(!legendColumn.HeaderBackColor.IsEmpty)
                                                                {
                                                                        redrawLegendBorder = true;

                                                                        // Fill title background
                                                                        if(fillRect.Right > legendPosition.Right)
                                                                        {
                                                                                fillRect.Width -= (legendPosition.Right - fillRect.Right);
                                                                        }
                                                                        if(fillRect.X < legendPosition.X)
                                                                        {
                                                                                fillRect.X += legendPosition.X - fillRect.X;
                                                                                fillRect.Width -= (legendPosition.X - fillRect.X);
                                                                        }
                                                                        fillRect.Intersect(legendPosition);
                                                                        chartGraph.FillRectangleRel( 
                                                                                chartGraph.GetRelativeRectangle(fillRect), 
                                                                                legendColumn.HeaderBackColor, 
                                                                                ChartHatchStyle.None,
                                                                                string.Empty,
                                                                                ChartImageWrapMode.Tile, 
                                                                                Color.Empty,
                                                                                ChartImageAlignmentStyle.Center,
                                                                                GradientStyle.None, 
                                                                                Color.Empty,
                                                                                Color.Empty, 
                                                                                0, 
                                                                                ChartDashStyle.NotSet, 
                                                                                Color.Empty, 
                                                                                0,
                                                                                PenAlignment.Inset);

                                                                }

                                                                // Draw header text
                                                                using(SolidBrush textBrush = new SolidBrush(legendColumn.HeaderForeColor))
                                                                {
                                                                        // Set text alignment
                                    using (StringFormat format = new StringFormat())
                                    {
                                        format.Alignment = legendColumn.HeaderAlignment;
                                        format.LineAlignment = StringAlignment.Center;
                                        format.FormatFlags = StringFormatFlags.LineLimit;
                                        format.Trimming = StringTrimming.EllipsisCharacter;

                                        // Draw string using relative coordinates
                                        chartGraph.DrawStringRel(
                                            legendColumn.HeaderText,
                                            legendColumn.HeaderFont,
                                            textBrush,
                                            chartGraph.GetRelativeRectangle(rect),
                                            format);
                                    }
                                                                }
                                                        }
                                                }
                                        }

                                        // Draw header separator for each column
                                        Rectangle separatorRect = this._headerPosition;
                                        separatorRect.X = columnStart;
                                        separatorRect.Width = columnWidth;
                                        if(this.HeaderSeparator == LegendSeparatorStyle.Line || this.HeaderSeparator == LegendSeparatorStyle.DoubleLine)
                                        {
                                                // NOTE: For some reason a line with a single pen width is drawn 1 pixel longer than 
                                                // any other line. Reduce width to solve the issue.
                                                legendPosition.Width -= 1;
                                        }
                                        separatorRect.Intersect(legendPosition);
                                        this.DrawSeparator(chartGraph, this.HeaderSeparator, this.HeaderSeparatorColor, true, separatorRect);

                                        // Add spacing between columns
                                        prevRightLocation += this.GetSeparatorSize(this.ItemColumnSeparator).Width;
                                }
                        
                                // Draw legend border to solve any issues with header background overlapping
                                if(redrawLegendBorder)
                                {
                                        chartGraph.FillRectangleRel( 
                                                chartGraph.GetRelativeRectangle(Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()))),
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.None, 
                                                Color.Empty,
                                                BorderColor, 
                                                this.GetBorderSize(), 
                                                BorderDashStyle, 
                                                Color.Empty, 
                                                0,
                                                PenAlignment.Inset);

                                }
                        
                                // Add legend header hot region
                                if( Common.ProcessModeRegions && !this._headerPosition.IsEmpty)
                                {
                                        Common.HotRegionsList.AddHotRegion(chartGraph.GetRelativeRectangle(this._headerPosition), this, ChartElementType.LegendHeader, true );
                                }

                        }
                }

                /// <summary>
                /// Draw Legend title.
                /// </summary>
                /// <param name="chartGraph">Chart graphics to draw the title on.</param>
                private void DrawLegendTitle(ChartGraphics chartGraph)
                {
                        // Check if title text is specified and position recalculated
                        if(this.Title.Length > 0 &&
                                !this._titlePosition.IsEmpty)
                        {
                                // Get Legend position
                                Rectangle legendPosition = Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()));
                                legendPosition.Y += this.GetBorderSize();
                                legendPosition.Height -= 2 * this.GetBorderSize();
                                legendPosition.X += this.GetBorderSize();
                                legendPosition.Width -= 2 * this.GetBorderSize();
                                if(this.GetBorderSize() > 0)
                                {
                                        ++legendPosition.Height;
                                        ++legendPosition.Width;
                                }

                                // Draw title background
                                if(!this.TitleBackColor.IsEmpty)
                                {
                                        // Fill title background
                                        Rectangle fillRect = this._titlePosition;
                                        fillRect.Intersect(legendPosition);
                                        chartGraph.FillRectangleRel( 
                                                chartGraph.GetRelativeRectangle(fillRect), 
                                                this.TitleBackColor, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.None, 
                                                Color.Empty,
                                                Color.Empty, 
                                                0, 
                                                ChartDashStyle.NotSet, 
                                                Color.Empty, 
                                                0,
                                                PenAlignment.Inset);
                                }

                                // Draw title text
                                using(SolidBrush textBrush = new SolidBrush(this.TitleForeColor))
                                {
                                        // Set text alignment
                                        StringFormat format = new StringFormat();
                                        format.Alignment = this.TitleAlignment;
                                        //format.LineAlignment = StringAlignment.Center;

                                        // Shift text rectangle by the top offset amount
                                        Rectangle rect = this._titlePosition;
                                        rect.Y += this._offset.Height;
                                        rect.X += this._offset.Width;
                                        rect.X += this.GetBorderSize();
                                        rect.Width -= this.GetBorderSize() * 2 + this._offset.Width;

                                        // Draw string using relative coordinates
                                        rect.Intersect(legendPosition);
                                        chartGraph.DrawStringRel(
                                                this.Title.Replace("\\n", "\n"),
                                                this.TitleFont,
                                                textBrush,
                                                chartGraph.GetRelativeRectangle(rect),
                                                format);
                                }

                                // Draw title separator
                                Rectangle separatorPosition = this._titlePosition;
                                if(this.TitleSeparator == LegendSeparatorStyle.Line || this.TitleSeparator == LegendSeparatorStyle.DoubleLine)
                                {
                                        // NOTE: For some reason a line with a single pen width is drawn 1 pixel longer than 
                                        // any other line. Reduce width to solve the issue.
                                        legendPosition.Width -= 1;
                                }
                                separatorPosition.Intersect(legendPosition);
                                this.DrawSeparator(chartGraph, this.TitleSeparator, this.TitleSeparatorColor, true, separatorPosition);

                                // Draw legend border to solve any issues with title background overlapping
                                if(!this.TitleBackColor.IsEmpty || 
                                        this.TitleSeparator != LegendSeparatorStyle.None)
                                {
                                        chartGraph.FillRectangleRel( 
                                                chartGraph.GetRelativeRectangle(Rectangle.Round(chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()))),
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.None, 
                                                Color.Empty,
                                                BorderColor, 
                                                this.GetBorderSize(), 
                                                BorderDashStyle, 
                                                Color.Empty, 
                                                0,
                                                PenAlignment.Inset);

                                }
                        }
                }

                /// <summary>
                /// Gets legend separator size in pixels
                /// </summary>
                /// <param name="separatorType">Separator type.</param>
                /// <returns>Separator size in relative coordinates.</returns>
                internal Size GetSeparatorSize(LegendSeparatorStyle separatorType)
                {
                        Size size = Size.Empty;

                        if(separatorType == LegendSeparatorStyle.None)
                        {
                                size = Size.Empty;
                        }
                        else if(separatorType == LegendSeparatorStyle.Line)
                        {
                                size = new Size(1, 1);
                        }
                        else if(separatorType == LegendSeparatorStyle.DashLine)
                        {
                                size = new Size(1, 1);
                        }
                        else if(separatorType == LegendSeparatorStyle.DotLine)
                        {
                                size = new Size(1, 1);
                        }
                        else if(separatorType == LegendSeparatorStyle.ThickLine)
                        {
                                size = new Size(2, 2);
                        }
                        else if(separatorType == LegendSeparatorStyle.DoubleLine)
                        {
                                size = new Size(3, 3);
                        }
                        else if(separatorType == LegendSeparatorStyle.GradientLine)
                        {
                                size = new Size(1, 1);
                        }
                        else if(separatorType == LegendSeparatorStyle.ThickGradientLine)
                        {
                                size = new Size(2, 2);
                        }
                        else
                        {
                throw (new InvalidOperationException(SR.ExceptionLegendSeparatorTypeUnknown(separatorType.ToString())));
                        }

                        // For the vertical part of the separator always add additiobal spacing
                        size.Width += this._itemColumnSpacingRel;

                        return size;
                }

                /// <summary>
                /// Draws specified legend separator.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <param name="separatorType">Separator type.</param>
                /// <param name="color">Separator color.</param>
                /// <param name="horizontal">Flag that determines if separator is vertical or horizontal.</param>
                /// <param name="position">Separator position.</param>
                private void DrawSeparator(
                        ChartGraphics chartGraph, 
                        LegendSeparatorStyle separatorType, 
                        Color color, 
                        bool horizontal,
                        Rectangle position)
                {
                        // Temporary disable antialiasing
                        SmoothingMode oldSmoothingMode = chartGraph.SmoothingMode;
                        chartGraph.SmoothingMode = SmoothingMode.None;

                        // Get line position in absolute coordinates
                        RectangleF rect = position;
                        if(!horizontal)
                        {
                                rect.X += (int)(_itemColumnSpacingRel / 2f);
                                rect.Width -= _itemColumnSpacingRel;
                        }
                        if(separatorType == LegendSeparatorStyle.Line)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Left, rect.Bottom - 1),
                                                new PointF(rect.Right, rect.Bottom - 1) );

                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Right - 1, rect.Top),
                                                new PointF(rect.Right - 1, rect.Bottom) );
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.DashLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Dash,
                                                new PointF(rect.Left, rect.Bottom - 1),
                                                new PointF(rect.Right, rect.Bottom - 1) );

                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Dash,
                                                new PointF(rect.Right - 1, rect.Top),
                                                new PointF(rect.Right - 1, rect.Bottom) );
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.DotLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Dot,
                                                new PointF(rect.Left, rect.Bottom - 1),
                                                new PointF(rect.Right, rect.Bottom - 1) );

                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Dot,
                                                new PointF(rect.Right - 1, rect.Top),
                                                new PointF(rect.Right - 1, rect.Bottom) );
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.ThickLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                2,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Left, rect.Bottom - 1f),
                                                new PointF(rect.Right, rect.Bottom - 1f) );
                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                2,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Right - 1f, rect.Top),
                                                new PointF(rect.Right - 1f, rect.Bottom) );
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.DoubleLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Left, rect.Bottom - 3),
                                                new PointF(rect.Right, rect.Bottom - 3) );
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Left, rect.Bottom - 1),
                                                new PointF(rect.Right, rect.Bottom - 1) );
                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Right - 3, rect.Top),
                                                new PointF(rect.Right - 3, rect.Bottom) );
                                        chartGraph.DrawLineAbs(
                                                color,
                                                1,
                                                ChartDashStyle.Solid,
                                                new PointF(rect.Right - 1, rect.Top),
                                                new PointF(rect.Right - 1, rect.Bottom) );
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.GradientLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.FillRectangleAbs( 
                                                new RectangleF(rect.Left, rect.Bottom - 1f, rect.Width, 0f), 
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.VerticalCenter, 
                                                color,
                                                Color.Empty, 
                                                0, 
                                                ChartDashStyle.NotSet, 
                                                PenAlignment.Inset);
                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.FillRectangleAbs( 
                                                new RectangleF(rect.Right - 1f, rect.Top, 0f, rect.Height), 
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.HorizontalCenter, 
                                                color,
                                                Color.Empty, 
                                                0, 
                                                ChartDashStyle.NotSet, 
                                                PenAlignment.Inset);
                                }
                        }
                        else if(separatorType == LegendSeparatorStyle.ThickGradientLine)
                        {
                                if(horizontal)
                                {
                                        // Draw horizontal line separator
                                        chartGraph.FillRectangleAbs( 
                                                new RectangleF(rect.Left, rect.Bottom - 2f, rect.Width, 1f), 
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.VerticalCenter, 
                                                color,
                                                Color.Empty, 
                                                0, 
                                                ChartDashStyle.NotSet, 
                                                PenAlignment.Inset);
                                }
                                else
                                {
                                        // Draw vertical line separator
                                        chartGraph.FillRectangleAbs( 
                                                new RectangleF(rect.Right - 2f, rect.Top, 1f, rect.Height), 
                                                Color.Transparent, 
                                                ChartHatchStyle.None,
                                                string.Empty,
                                                ChartImageWrapMode.Tile, 
                                                Color.Empty,
                                                ChartImageAlignmentStyle.Center,
                                                GradientStyle.HorizontalCenter, 
                                                color,
                                                Color.Empty, 
                                                0, 
                                                ChartDashStyle.NotSet, 
                                                PenAlignment.Inset);
                                }
                        }

                        // Restore smoothing
                        chartGraph.SmoothingMode = oldSmoothingMode;
                }

                #endregion // Legent Title Helper methods

                #region Helper methods

                /// <summary>
                /// Get visible legend border size.
                /// </summary>
                /// <returns>Visible legend border size.</returns>
                private int GetBorderSize()
                {
                        if(this.BorderWidth > 0 &&
                                this.BorderDashStyle != ChartDashStyle.NotSet &&
                                !this.BorderColor.IsEmpty &&
                                this.BorderColor != Color.Transparent)
                        {
                                return this.BorderWidth;
                        }
                        return 0;
                }

                /// <summary>
                /// Helper method which returns current legend table style.
                /// </summary>
                /// <param name="chartGraph">Chart graphics.</param>
                /// <returns>Legend table style.</returns>
                private LegendTableStyle GetLegendTableStyle(ChartGraphics chartGraph)
                {
                        LegendTableStyle style = this.TableStyle;
                        if(this.TableStyle == LegendTableStyle.Auto)
                        {
                                if(this.Position.Auto)
                                {
                                        // If legend is automatically positioned, use docking
                                        // do determine preffered table style
                                        if(this.Docking == Docking.Left ||
                                                this.Docking == Docking.Right)
                                        {
                                                return LegendTableStyle.Tall;
                                        }
                                        else
                                        {
                                                return LegendTableStyle.Wide;
                                        }
                                }
                                else
                                {
                                        // If legend is custom positioned, use legend width and heiht
                                        // to determine the best table layout.
                                        SizeF legendPixelSize = chartGraph.GetAbsoluteRectangle(this.Position.ToRectangleF()).Size;
                                        if(legendPixelSize.Width < legendPixelSize.Height)
                                        {
                                                return LegendTableStyle.Tall;
                                        }
                                        else
                                        {
                                                return LegendTableStyle.Wide;
                                        }
                                }
                        }
                        
                        return style;
                }



                /// <summary>
                /// Helper method that checks if legend is enabled.
                /// </summary>
                /// <returns>True if legend is enabled.</returns>
                internal bool IsEnabled()
                {
                        if(this.Enabled)
                        {

                                // Check if legend is docked to the chart area
                                if(this.DockedToChartArea.Length > 0 &&
                                        this.Common != null &&
                                        this.Common.ChartPicture != null)
                                {
                                        if(this.Common.ChartPicture.ChartAreas.IndexOf(this.DockedToChartArea) >= 0)
                                        {
                                                // Do not show legend when it is docked to invisible chart area
                                                ChartArea area = this.Common.ChartPicture.ChartAreas[this.DockedToChartArea];
                                                if(!area.Visible)
                                                {
                                                        return false;
                                                }
                                        }
                                }
                                        

                                return true;
                        }
                        return false;
                }

                /// <summary>
                /// Invalidate chart legend when one of the properties is changed
                /// </summary>
                /// <param name="invalidateLegendOnly">Indicates that only legend area should be invalidated.</param>
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "This parameter is used when compiling for the Microsoft version of Chart")]
                internal void Invalidate(bool invalidateLegendOnly)
                {
#if Microsoft_CONTROL

                        if(Chart != null && !Chart.disableInvalidates)
                        {
                                if(invalidateLegendOnly)
                                {
                                        // Calculate the position of the legend
                                        Rectangle       invalRect = Chart.ClientRectangle;
                                        if(this.Position.Width != 0 && this.Position.Height != 0 )
                                        {
                                                // Convert relative coordinates to absolute coordinates
                                                invalRect.X = (int)(this.Position.X * (this.Common.ChartPicture.Width - 1) / 100F); 
                                                invalRect.Y = (int)(this.Position.Y * (this.Common.ChartPicture.Height - 1) / 100F); 
                                                invalRect.Width = (int)(this.Position.Width * (this.Common.ChartPicture.Width - 1) / 100F); 
                                                invalRect.Height = (int)(this.Position.Height * (this.Common.ChartPicture.Height - 1) / 100F); 

                                                // Inflate rectangle size using border size and shadow size
                        invalRect.Inflate(this.BorderWidth + this.ShadowOffset + 1, this.BorderWidth + this.ShadowOffset + 1);
                                        }

                                        // Invalidate legend rectangle only
                                        Chart.dirtyFlag = true;
                                        Chart.Invalidate(invalRect);
                                }
                                else
                                {
                                        Invalidate();
                                }
                        }
#endif
                }

                #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)
            {
                //Free managed resources
                if (_fontCache != null)
                {
                    _fontCache.Dispose();
                    _fontCache = null;
                }
                if (legendItems != null)
                {
                    legendItems.Dispose();
                    legendItems = null;
                }
                if (_cellColumns != null)
                {
                    _cellColumns.Dispose();
                    _cellColumns = null;
                }
                if (_customLegends != null)
                {
                    _customLegends.Dispose();
                    _customLegends = null;
                }
                if (_position != null)
                {
                    _position.Dispose();
                    _position = null;
                }
            }
        }


        #endregion
    }

        /// <summary>
    /// The LegendCollection class is a strongly typed collection of legends.
        /// </summary>
        [
                SRDescription("DescriptionAttributeLegendCollection_LegendCollection"),
        ]
#if ASPPERM_35
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class LegendCollection : ChartNamedElementCollection<Legend>
    {
        #region Constructors
                /// <summary>
        /// LegendCollection constructor.
                /// </summary>
        /// <param name="chartPicture">Chart picture object.</param>
        internal LegendCollection(ChartPicture chartPicture)
            : base(chartPicture)
        {
        }

                #endregion

        #region Properties
        /// <summary>
        /// Gets the default legend name.
        /// </summary>
        internal string DefaultNameReference
        {
            get { return this.Count > 0 ? this[0].Name : String.Empty; }
        }
        #endregion

                #region Methods

        /// <summary>
        /// Creates a new Legend with the specified name and adds it to the collection.
        /// </summary>
        /// <param name="name">The new chart area name.</param>
        /// <returns>New legend</returns>
        public Legend Add(string name)
        {
            Legend legend = new Legend(name);
            this.Add(legend);
            return legend;
        }

        /// <summary>
                /// Recalculates legend position in the collection.
                /// </summary>
                /// <param name="chartGraph">Chart graphics used.</param>
                /// <param name="chartAreasRectangle">Area where the legend should be positioned.</param>
                /// <param name="elementSpacing">Spacing size as a percentage of the area.</param>
                internal void CalcLegendPosition(
                        ChartGraphics chartGraph, 
                        ref RectangleF chartAreasRectangle, 
                        float elementSpacing)
                {
                        // Loop through all legends
                        foreach(Legend legend in this)
                        {
                                // Calculate position of the legends docked to the chart picture
                                if(legend.IsEnabled() &&
                    legend.DockedToChartArea == Constants.NotSetValue && 
                                        legend.Position.Auto)
                                {
                                        legend.CalcLegendPosition(chartGraph, ref chartAreasRectangle, elementSpacing);
                                }
                        }
                }

                /// <summary>
                /// Recalculates legend position in the collection for legends docked outside of chart area.
                /// </summary>
                /// <param name="chartGraph">Chart graphics used.</param>
                /// <param name="area">Area the legend is docked to.</param>
                /// <param name="chartAreasRectangle">Area where the legend should be positioned.</param>
                /// <param name="elementSpacing">Spacing size as a percentage of the area.</param>
                internal void CalcOutsideLegendPosition(
                        ChartGraphics chartGraph, 
                        ChartArea area,
                        ref RectangleF chartAreasRectangle, 
                        float elementSpacing)
                {
                        if(Common != null && Common.ChartPicture != null)
                        {
                                // Get elemets spacing
                                float areaSpacing = Math.Min((chartAreasRectangle.Height/100F) * elementSpacing, (chartAreasRectangle.Width/100F) * elementSpacing);

                                // Loop through all legends
                                foreach(Legend legend in this)
                                {
                                        // Check if all chart area names are valid
                    if (legend.DockedToChartArea != Constants.NotSetValue && this.Chart.ChartAreas.IndexOf(legend.DockedToChartArea)<0)
                    {
                        throw (new ArgumentException(SR.ExceptionLegendDockedChartAreaIsMissing((string)legend.DockedToChartArea)));
                    }

                                        // Process only legends docked to specified area
                                        if(legend.IsEnabled() && 
                                                legend.IsDockedInsideChartArea == false &&
                                                legend.DockedToChartArea == area.Name && 
                                                legend.Position.Auto)
                                        {
                                                // Calculate legend position
                                                legend.CalcLegendPosition(chartGraph, 
                                                        ref chartAreasRectangle,
                                                        areaSpacing);

                                                // Adjust legend position
                                                RectangleF legendPosition = legend.Position.ToRectangleF();
                                                if(legend.Docking == Docking.Top)
                                                {
                                                        legendPosition.Y -= areaSpacing;
                                                        if(!area.Position.Auto)
                                                        {
                                                                legendPosition.Y -= legendPosition.Height;
                                                        }
                                                }
                                                else if(legend.Docking == Docking.Bottom)
                                                {
                                                        legendPosition.Y += areaSpacing;
                                                        if(!area.Position.Auto)
                                                        {
                                                                legendPosition.Y = area.Position.Bottom + areaSpacing;
                                                        }
                                                }
                                                if(legend.Docking == Docking.Left)
                                                {
                                                        legendPosition.X -= areaSpacing;
                                                        if(!area.Position.Auto)
                                                        {
                                                                legendPosition.X -= legendPosition.Width;
                                                        }
                                                }
                                                if(legend.Docking == Docking.Right)
                                                {
                                                        legendPosition.X += areaSpacing;
                                                        if(!area.Position.Auto)
                                                        {
                                                                legendPosition.X = area.Position.Right + areaSpacing;
                                                        }
                                                }

                                                legend.Position.SetPositionNoAuto(legendPosition.X, legendPosition.Y, legendPosition.Width, legendPosition.Height);
                                        }
                                }
                        }
                }

                /// <summary>
                /// Recalculates legend position inside chart area in the collection.
                /// </summary>
                /// <param name="chartGraph">Chart graphics used.</param>
                /// <param name="elementSpacing">Spacing size as a percentage of the area.</param>
                internal void CalcInsideLegendPosition(
                        ChartGraphics chartGraph, 
                        float elementSpacing)
                {
                        if(Common != null && Common.ChartPicture != null)
                        {
                                // Check if all chart area names are valid
                                foreach(Legend legend in this)
                                {
                    if (legend.DockedToChartArea != Constants.NotSetValue)
                                        {
                                                try
                                                {
                                                        ChartArea area = Common.ChartPicture.ChartAreas[legend.DockedToChartArea];
                                                }
                                                catch
                                                {
                                                        throw(new ArgumentException( SR.ExceptionLegendDockedChartAreaIsMissing( (string)legend.DockedToChartArea ) ) );
                                                }
                                        }
                                }

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

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

                                        {
                                                // Get area position
                                                RectangleF legendPlottingRectangle = area.PlotAreaPosition.ToRectangleF();

                                                // Get elemets spacing
                                                float areaSpacing = Math.Min((legendPlottingRectangle.Height/100F) * elementSpacing, (legendPlottingRectangle.Width/100F) * elementSpacing);

                                                // Loop through all legends
                                                foreach(Legend legend in this)
                                                {
                                                        if(legend.IsEnabled() && 
                                                                legend.IsDockedInsideChartArea == true &&
                                                                legend.DockedToChartArea == area.Name && 
                                                                legend.Position.Auto)
                                                        {
                                                                // Calculate legend position
                                                                legend.CalcLegendPosition(chartGraph, 
                                                                        ref legendPlottingRectangle,
                                                                        areaSpacing);
                                                        }
                                                }
                                        }
                                }
                        }
                }

                #endregion

        #region Event handlers
        internal void ChartAreaNameReferenceChanged(object sender, NameReferenceChangedEventArgs e)
        {
            //If all the chart areas are removed and then the first one is added we don't want to dock the legends
            if (e.OldElement == null)
                return;

            foreach (Legend legend in this)
                if (legend.DockedToChartArea == e.OldName)
                    legend.DockedToChartArea = e.NewName;
        }
        #endregion

    }

        /// <summary>
    /// The LegendItemsCollection class is a strongly typed collection of legend items.
        /// </summary>
        [
                SRDescription("DescriptionAttributeCustomLabelsCollection_CustomLabelsCollection"),
        ]
#if ASPPERM_35
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class LegendItemsCollection : ChartElementCollection<LegendItem>
        {
        #region Constructors

        /// <summary>
        /// LegendItemsCollection constructor
                /// </summary>
        internal LegendItemsCollection(Legend legend)
            : base(legend)
        {
        }

                #endregion

                #region Methods

                /// <summary>
                /// Adds a legend item into the collection.
                /// </summary>
                /// <param name="color">Legend item color.</param>
                /// <param name="text">Legend item text.</param>
                /// <returns>Index of newly added item.</returns>
                public int Add(Color color, string text)
                {
                        LegendItem      item = new LegendItem(text, color, "");
                        Add(item);
            return Count - 1;
                }

                /// <summary>
                /// Insert a legend item into the collection.
                /// </summary>
                /// <param name="index">Index to insert at.</param>
                /// <param name="color">Legend item color.</param>
                /// <param name="text">Legend item text.</param>
                /// <returns>Index of newly added item.</returns>
                public void Insert(int index, Color color, string text)
                {
                        LegendItem      item = new LegendItem(text, color, "");
                        this.Insert(index, item);
                }

                /// <summary>
                /// Adds a legend item into the collection.
                /// </summary>
                /// <param name="image">Legend item image.</param>
                /// <param name="text">Legend item text.</param>
                /// <returns>Index of newly added item.</returns>
                public int Add(string image, string text)
                {
                        LegendItem      item = new LegendItem(text, Color.Empty, image);
            Add(item);
                        return Count-1;
                }

                /// <summary>
                /// Insert one legend item into the collection.
                /// </summary>
                /// <param name="index">Index to insert at.</param>
                /// <param name="image">Legend item image.</param>
                /// <param name="text">Legend item text.</param>
                /// <returns>Index of newly added item.</returns>
                public void Insert(int index, string image, string text)
                {
                        LegendItem      item = new LegendItem(text, Color.Empty, image);
                        this.Insert(index, item);
                }

                /// <summary>
                /// Reverses the order of items in the collection.
                /// </summary>
                public void Reverse()
                {
            List<LegendItem> list = this.Items as List<LegendItem>;
            list.Reverse();
                        Invalidate();
                }

                #endregion

        }


        /// <summary>
    /// The LegendItem class represents a single item (row) in the legend.
    /// It contains properties which describe visual appearance and
    /// content of the legend item.
        /// </summary>
        [
        SRDescription("DescriptionAttributeLegendItem_LegendItem"),
        DefaultProperty("Name"),
        ]
#if Microsoft_CONTROL
        public class LegendItem : ChartNamedElement
#else
#if ASPPERM_35
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
    public class LegendItem : ChartNamedElement, IChartMapArea
#endif
    {
        #region Fields

        // Private data members, which store properties values
                private Color                                   _color = Color.Empty;
                private string                                  _image = "";
                private string                                  _seriesName = "";
                private int                                             _seriesPointIndex = -1;

                // Chart image map properties 
                private string                                  _toolTip = "";
        
#if !Microsoft_CONTROL
                private string                                  _url = "";
                private string                                  _attributes = "";
        private string                  _postbackValue = String.Empty;
#endif

        // Additional appearance properties
                internal LegendImageStyle               style = LegendImageStyle.Rectangle;
                internal GradientStyle                  backGradientStyle = GradientStyle.None;
                internal Color                                  backSecondaryColor = Color.Empty;
                internal Color                                  backImageTransparentColor = Color.Empty;
                internal Color                                  borderColor = Color.Black;
                internal int                                    borderWidth = 1;
                internal ChartDashStyle                 borderDashStyle = ChartDashStyle.Solid;
                internal ChartHatchStyle                backHatchStyle = ChartHatchStyle.None;
                internal int                                    shadowOffset = 0;
                internal Color                                  shadowColor = Color.FromArgb(128, 0, 0, 0);
                internal ChartImageWrapMode             backImageWrapMode = ChartImageWrapMode.Tile;
                internal ChartImageAlignmentStyle               backImageAlign = ChartImageAlignmentStyle.TopLeft;

                // Marker properties
                internal MarkerStyle                    markerStyle = MarkerStyle.None;
                internal int                                    markerSize = 5;
                internal string                                 markerImage = "";
                internal Color                                  markerImageTransparentColor = Color.Empty;
                internal Color                                  markerColor = Color.Empty;
                internal Color                                  markerBorderColor = Color.Empty;

                // True if legend item is enabled.
                private bool            _enabled = true;

                // Series marker border width
                private int                     _markerBorderWidth = 1;

                // Collection of legend item cells
                private LegendCellCollection    _cells = null;

                // Legend item visual separator
                private LegendSeparatorStyle    _separatorType = LegendSeparatorStyle.None;

                // Legend item visual separator color
                private Color           _separatorColor = Color.Black;

                // Indicates that temporary cells where added and thet have to be removed
                internal bool           clearTempCells = false;

                #endregion

                #region Constructors

                /// <summary>
        /// LegendItem constructor
                /// </summary>
                public LegendItem()
                {

                        // Create collection of legend item cells
                        this._cells = new LegendCellCollection(this);
#if !Microsoft_CONTROL
            this.PostBackValue = String.Empty;
#endif //!WIN_CONTROL
                }

                /// <summary>
        /// LegendItem constructor
                /// </summary>
                /// <param name="name">Item name.</param>
                /// <param name="color">Item color.</param>
                /// <param name="image">Item image.</param>
                public LegendItem(string name, Color color, string image) : base (name)
                {
                        this._color = color;
                        this._image = image;

                        // Create collection of legend item cells
                        this._cells = new LegendCellCollection(this);
#if !Microsoft_CONTROL
            this.PostBackValue = String.Empty;
#endif //!WIN_CONTROL
                }

                #endregion

                #region Legend item properties

        /// <summary>
        /// Gets the Legend object which the item belongs to.
        /// </summary>
        [
            Bindable(false),
            Browsable(false),
            DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
            SerializationVisibilityAttribute(SerializationVisibility.Hidden),
        ]
        public Legend Legend
        {
            get 
            {
                if (Parent != null)
                    return Parent.Parent as Legend;
                else
                    return null;
            }
        }

                /// <summary>
                /// Gets or sets the name of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                SRDescription("DescriptionAttributeLegendItem_Name"),
                NotifyParentPropertyAttribute(true),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                ParenthesizePropertyNameAttribute(true)
                ]
                public override string Name
                {
                        get
                        {
                                return base.Name;
                        }
                        set
                        {
                                base.Name = value;
                        }
                }

                /// <summary>
                /// Gets or sets the color of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                SRDescription("DescriptionAttributeLegendItem_Color"),
                DefaultValue(typeof(Color), ""),
                NotifyParentPropertyAttribute(true),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public  Color Color
                {
                        get
                        {
                                return _color;
                        }
                        set
                        {
                                _color = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets a string value that represents a URL to an image file, which will be used for the legend item's symbol.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                SRDescription("DescriptionAttributeLegendItem_Image"),
                DefaultValue(""),
        Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                NotifyParentPropertyAttribute(true)
                ]
                public  string Image
                {
                        get
                        {
                                return _image;
                        }
                        set
                        {
                                _image = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the picture style of the legend item image.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(LegendImageStyle), "Rectangle"),
                SRDescription("DescriptionAttributeLegendItem_Style"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                ParenthesizePropertyNameAttribute(true)
                ]
                public LegendImageStyle ImageStyle
                {
                        get
                        {
                                return style;
                        }
                        set
                        {
                                style = value;
                                this.Invalidate(true);
                        }
                }


                /// <summary>
                /// Gets or sets the border color of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "Black"),
        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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets the background hatch style of the legend item.
                /// </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;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets a color which will be replaced with a transparent color while drawing the background image.
                /// </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;
                                this.Invalidate(true);
                        }
                }

        /// <summary>
        /// Gets or sets background gradient style of the legend item.
        /// </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;
                                this.Invalidate(true);
                        }
                }

        /// <summary>
        /// Gets or sets the secondary background color.
        /// <seealso cref="Color"/>
        /// <seealso cref="BackHatchStyle"/>
        /// <seealso cref="BackGradientStyle"/>
        /// </summary>
        /// <value>
        /// A <see cref="Color"/> value used for the secondary color of background with 
        /// hatching or gradient fill.
        /// </value>
        /// <remarks>
        /// This color is used with <see cref="Color"/> when <see cref="BackHatchStyle"/> or
        /// <see cref="BackGradientStyle"/> are used.
        /// </remarks>
                [
                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(value != Color.Empty && (value.A != 255 || value == Color.Transparent))
                                {
                    throw (new ArgumentException(SR.ExceptionBackSecondaryColorIsTransparent));
                                }

                                backSecondaryColor = value;

                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the border width of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(1),
        SRDescription("DescriptionAttributeBorderWidth"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public int BorderWidth
                {
                        get
                        {
                                return borderWidth;
                        }
                        set
                        {
                                if(value < 0)
                                {
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsZero));
                                }
                                borderWidth = value;
                                this.Invalidate(false);
                        }
                }



        /// <summary>
        /// Gets or sets a flag which indicates whether the Legend item is enabled.
        /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(true),
                SRDescription("DescriptionAttributeLegendItem_Enabled"),
                ParenthesizePropertyNameAttribute(true),
                ]
                public bool Enabled
                {
                        get
                        {
                                return this._enabled;
                        }
                        set
                        {
                                this._enabled = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
                /// Gets or sets the marker border width of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                DefaultValue(1),
        SRDescription("DescriptionAttributeMarkerBorderWidth"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public int MarkerBorderWidth
                {
                        get
                        {
                                return this._markerBorderWidth;
                        }
                        set
                        {
                                if(value < 0)
                                {
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionLegendMarkerBorderWidthIsNegative));
                                }
                                this._markerBorderWidth = value;
                                this.Invalidate(false);
                        }
                }



        /// <summary>
        /// Gets or sets the legend item border style.
        /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(ChartDashStyle.Solid),
        SRDescription("DescriptionAttributeBorderDashStyle"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public ChartDashStyle BorderDashStyle
                {
                        get
                        {
                                return borderDashStyle;
                        }
                        set
                        {
                                borderDashStyle = value;
                                this.Invalidate(true);
                        }
                }

        /// <summary>
        /// Gets or sets the offset between the legend item and its shadow.
        /// <seealso cref="ShadowColor"/>
        /// </summary>
        /// <value>
        /// An integer value that represents the offset between the legend item and its shadow.
        /// </value>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
        SRDescription("DescriptionAttributeShadowOffset"),
#if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
                DefaultValue(0)
                ]
                public int ShadowOffset
                {
                        get
                        {
                                return shadowOffset;
                        }
                        set
                        {
                                shadowOffset = value;
                                this.Invalidate(false);
                        }
                }

        /// <summary>
        /// Gets or sets the color of a legend item's shadow.
        /// <seealso cref="ShadowOffset"/>
        /// </summary>
        /// <value>
        /// A <see cref="Color"/> value used to draw a legend item's shadow.
        /// </value>
                [
                SRCategory("CategoryAttributeAppearance"),
                Bindable(true),
                DefaultValue(typeof(Color), "128,0,0,0"),
        SRDescription("DescriptionAttributeShadowColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public Color ShadowColor
                {
                        get
                        {
                                return shadowColor;
                        }
                        set
                        {
                                shadowColor = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
                /// Gets or sets the marker style of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(MarkerStyle.None),
                SRDescription("DescriptionAttributeLegendItem_MarkerStyle"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
        Editor(Editors.MarkerStyleEditor.Editor, Editors.MarkerStyleEditor.Base),
                RefreshProperties(RefreshProperties.All)
                ]
                public MarkerStyle MarkerStyle
                {
                        get
                        {
                                return markerStyle;
                        }
                        set
                        {
                                markerStyle = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets the marker size of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(5),
                SRDescription("DescriptionAttributeLegendItem_MarkerSize"),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                RefreshProperties(RefreshProperties.All)
                ]
                public int MarkerSize
                {
                        get
                        {
                                return markerSize;
                        }
                        set
                        {
                                markerSize = value;
                                this.Invalidate(false);
                        }
                }

                /// <summary>
        /// Gets or sets the marker image of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(""),
        SRDescription("DescriptionAttributeMarkerImage"),
        Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                RefreshProperties(RefreshProperties.All)
                ]
                public string MarkerImage
                {
                        get
                        {
                                return markerImage;
                        }
                        set
                        {
                                markerImage = value;
                                this.Invalidate(true);
                        }
                }

                /// <summary>
        /// Gets or sets a color which will be replaced with a transparent color while drawing the marker image.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeImageTransparentColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                RefreshProperties(RefreshProperties.All)
                ]
                public Color MarkerImageTransparentColor
                {
                        get
                        {
                                return markerImageTransparentColor;
                        }
                        set
                        {
                                markerImageTransparentColor = value;
                                this.Invalidate(true);
                        }
                }
                
                /// <summary>
        /// Gets or sets the marker color of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
                SRDescription("DescriptionAttributeLegendItem_MarkerColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                RefreshProperties(RefreshProperties.All)
                ]
                public Color MarkerColor
                {
                        get
                        {
                                return markerColor;
                        }
                        set
                        {
                                markerColor = value;
                                this.Invalidate(true);
                        }
                }
                
                /// <summary>
        /// Gets or sets the marker border color of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeMarker"),
                Bindable(true),
                DefaultValue(typeof(Color), ""),
        SRDescription("DescriptionAttributeMarkerBorderColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
                #endif
                RefreshProperties(RefreshProperties.All)
                ]
                public Color MarkerBorderColor
                {
                        get
                        {
                                return markerBorderColor;
                        }
                        set
                        {
                                markerBorderColor = value;
                                this.Invalidate(true);
                        }
                }


                /// <summary>
        /// Gets or sets the series name of the legend item..
                /// </summary>
                [
                Browsable(false),
        DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
        SerializationVisibilityAttribute(SerializationVisibility.Hidden),
        SRDescription("DescriptionAttributeLegendItem_SeriesName"),
                DefaultValue("")
                ]
                public  string SeriesName
                {
                        get
                        {
                                return _seriesName;
                        }
                        set
                        {
                                _seriesName = value;
                        }
                }

                /// <summary>
        /// Gets or sets the index of the legend item's associated DataPoint object.
                /// </summary>
                [
                Browsable(false),
        DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
        SerializationVisibilityAttribute(SerializationVisibility.Hidden),
        SRDescription("DescriptionAttributeLegendItem_SeriesPointIndex"),
                DefaultValue(-1)
                ]
                public  int SeriesPointIndex
                {
                        get
                        {
                                return _seriesPointIndex;
                        }
                        set
                        {
                                _seriesPointIndex = value;
                        }
                }




                /// <summary>
                /// Gets or sets the separator style of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(typeof(LegendSeparatorStyle), "None"),
                SRDescription("DescriptionAttributeLegendItem_Separator"),
                ]
                public LegendSeparatorStyle SeparatorType
                {
                        get
                        {
                                return this._separatorType;
                        }
                        set
                        {
                                if(value != this._separatorType)
                                {
                                        this._separatorType = value;
                                        this.Invalidate(false);
                                }
                        }
                }

                /// <summary>
        /// Gets or sets the separator color of the legend item.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                DefaultValue(typeof(Color), "Black"),
                SRDescription("DescriptionAttributeLegendItem_SeparatorColor"),
        TypeConverter(typeof(ColorConverter)),
        Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
                ]
                public Color SeparatorColor
                {
                        get
                        {
                                return this._separatorColor;
                        }
                        set
                        {
                                if(value != this._separatorColor)
                                {
                                        this._separatorColor = value;
                                        this.Invalidate(false);
                                }
                        }
                }


                /// <summary>
        /// The LegendCellCollection class is a collection of legend item cells.
                /// </summary>
                [
                SRCategory("CategoryAttributeAppearance"),
                SRDescription("DescriptionAttributeLegendItem_Cells"),
#if Microsoft_CONTROL
                DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
#else
                PersistenceMode(PersistenceMode.InnerProperty),
#endif
        Editor(Editors.LegendCellCollectionEditor.Editor, Editors.LegendCellCollectionEditor.Base),
                ]
                public LegendCellCollection Cells
                {
                        get
                        {
                                return this._cells;
                        }
                }

                #endregion

                #region IMapAreaAttributesutes Properties implementation

                /// <summary>
                /// Tooltip of the area.
                /// </summary>
                [
                SRCategory("CategoryAttributeMapArea"),
        Bindable(true),
        SRDescription("DescriptionAttributeToolTip"),
                DefaultValue(""),
                #if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute)
                #endif
                ]
                public string ToolTip
                {
                        set
                        {
                                _toolTip = value;
#if Microsoft_CONTROL
                                if(Chart != null && Chart.selection != null)
                                {
                                        Chart.selection.enabledChecked = false;
                                }
#endif

                        }
                        get
                        {
                                return _toolTip;
                        }
                }

#if !Microsoft_CONTROL
                /// <summary>
                /// URL target of the area.
                /// </summary>
                [
                SRCategory("CategoryAttributeMapArea"),
                Bindable(true),
                SRDescription("DescriptionAttributeUrl"),
                DefaultValue(""),
#if !Microsoft_CONTROL
                PersistenceMode(PersistenceMode.Attribute),
        Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base)
#endif
                ]
                public string Url
                {
                        set
                        {
                                _url = value;
                        }
                        get
                        {
                                return _url;
                        }
                }

#endif
#if !Microsoft_CONTROL

                /// <summary>
                /// Other attributes of the area.
                /// </summary>
                [
                SRCategory("CategoryAttributeMapArea"),
                Bindable(true),
                SRDescription("DescriptionAttributeMapAreaAttributes"),
                DefaultValue(""),
                PersistenceMode(PersistenceMode.Attribute)
                ]
                public string MapAreaAttributes
                {
                        set
                        {
                                _attributes = value;
                        }
                        get
                        {
                                return _attributes;
                        }
                }
        /// <summary>
        /// Gets or sets the postback value which can be processed on a click event.
        /// </summary>
        /// <value>The value which is passed to a click event as an argument.</value>
        [DefaultValue("")]
        [SRCategory(SR.Keys.CategoryAttributeMapArea)]
        [SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
        public string PostBackValue 
        {
            get
            {
                return this._postbackValue;
            }
            set
            {
                this._postbackValue = value;
            } 
        }


#endif //!Microsoft_CONTROL
        #endregion

        #region Helper methods

        /// <summary>
                /// Helper method adds default legend item cells based on the columns
                /// specified. If columns collection is empty we assume the presence of
                /// two columns: series marker and legend item text.
                /// </summary>
                /// <param name="legend">Legend this item belongs to.</param>
                internal void AddAutomaticCells(Legend legend)
                {
                        // Check if cells defined
                        if(this.Cells.Count == 0)
                        {
                                // Check if legend item was generated for the series
                                if(this.SeriesName.Length > 0)
                                {
                                        // If legend do not have any columns set add a series marker
                                        // and legend text cells
                                        if(legend.CellColumns.Count == 0)
                                        {
                        // VSTS 96787 - Text Direction (RTL/LTR)        
                        if (legend.Common != null && legend.Common.ChartPicture.RightToLeft == RightToLeft.Yes)
                        {
                            this.Cells.Add(LegendCellType.Text, KeywordName.LegendText, ContentAlignment.MiddleLeft);
                            this.Cells.Add(LegendCellType.SeriesSymbol, string.Empty, ContentAlignment.MiddleCenter);
                        }
                        else
                        {
                            this.Cells.Add(LegendCellType.SeriesSymbol, string.Empty, ContentAlignment.MiddleCenter);
                            this.Cells.Add(LegendCellType.Text, KeywordName.LegendText, ContentAlignment.MiddleLeft);
                        }
                                        }
                                        else
                                        {
                                                // Add cell for each of the columns
                                                foreach(LegendCellColumn legendColumn in legend.CellColumns)
                                                {
                                                        this.Cells.Add(legendColumn.CreateNewCell());
                                                }
                                        }
                                }
                                else
                                {
                                        // Add Marker plus text for everything else
                                        this.clearTempCells = true;
                                        this.Cells.Add(LegendCellType.SeriesSymbol, string.Empty, ContentAlignment.MiddleCenter);
                                        this.Cells.Add(LegendCellType.Text, KeywordName.LegendText, ContentAlignment.MiddleLeft);
                                }
                        }
                }


                /// <summary>
                /// Sets legend item properties from the series
                /// </summary>
                /// <param name="series">Series object.</param>
                /// <param name="common">Common elements object.</param>
                internal void SetAttributes(CommonElements common, Series series)
                {
                        // Get legend item picture style
                        IChartType chartType = common.ChartTypeRegistry.GetChartType(series.ChartTypeName);
                        style = chartType.GetLegendImageStyle(series);

                        // Set series name
                        _seriesName = series.Name;

                        // Get shadow properties
                        shadowOffset = series.ShadowOffset;
                        shadowColor = series.ShadowColor;

                        // Check if series is drawn in 3D chart area
                        bool area3D = common.Chart.ChartAreas[series.ChartArea].Area3DStyle.Enable3D;

                        // Get other properties
                        SetAttributes((DataPointCustomProperties) series, area3D);
                }

                /// <summary>
                /// Sets legend item properties from the DataPointCustomProperties object.
                /// </summary>
        /// <param name="properties">DataPointCustomProperties object.</param>
                /// <param name="area3D">Element belongs to the 3D area.</param>
        internal void SetAttributes(DataPointCustomProperties properties, bool area3D)
                {
                        borderColor = properties.BorderColor;
                        borderWidth = properties.BorderWidth;
                        borderDashStyle = properties.BorderDashStyle;
                        markerStyle = properties.MarkerStyle;
                        markerSize = properties.MarkerSize;
                        markerImage = properties.MarkerImage;
                        markerImageTransparentColor = properties.MarkerImageTransparentColor;
                        markerColor = properties.MarkerColor;
                        markerBorderColor = properties.MarkerBorderColor;


                        this._markerBorderWidth = properties.MarkerBorderWidth;
            
            float dpi = 96;

            if(Common != null)
                dpi = Common.graph.Graphics.DpiX;
            
            int maxBorderWidth = (int)Math.Round((2 * dpi) / 96);

            if (this._markerBorderWidth > maxBorderWidth)
                        {
                this._markerBorderWidth = maxBorderWidth;
                        }

                        if(properties.MarkerBorderWidth <= 0)
                        {
                                markerBorderColor = Color.Transparent;
                        }

                        // Improve readability of the line series marker by using at least 2 pixel wide lines
                        if(this.style == LegendImageStyle.Line &&
                borderWidth <= (int)Math.Round(dpi / 96) )
                        {
                borderWidth = maxBorderWidth;
                        }

                        if(!area3D)
                        {
                                backGradientStyle = properties.BackGradientStyle;
                                backSecondaryColor = properties.BackSecondaryColor;
                                backImageTransparentColor = properties.BackImageTransparentColor;
                                backImageWrapMode = properties.BackImageWrapMode;
                                backImageAlign = properties.BackImageAlignment;
                                backHatchStyle = properties.BackHatchStyle;
                        }
                }

                /// <summary>
                /// Invalidate chart (or just legend )when collection is changed
                /// </summary>
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "This parameter is used when compiling for the Microsoft version of Chart")]
                private void Invalidate(bool invalidateLegendOnly)
                {
#if Microsoft_CONTROL
                        if(Legend != null)
                        {
                                // Invalidate control
                                Legend.Invalidate(invalidateLegendOnly);
                        }
#endif
                }

                #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)
            {
                if (_cells != null)
                {
                    _cells.Dispose();
                    _cells = null;
                }
            }
            base.Dispose(disposing);
        }


        #endregion

        }
}