//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:		LegendColumns.cs
//
//  Namespace:	DataVisualization.Charting
//
//	Classes:	LegendCellColumn, LegendCellColumnCollection, 
//				LegendCell, LegendCellCollection, Margins
//
//  Purpose:	LegendCell and LegendCellColumn classes allow to 
//              create highly customize legends. Please refer to 
//              Chart documentation which contains images and 
//              samples describing this functionality.
//
//	Reviewed:	AG - Microsoft 14, 2007
//
//===================================================================

#region Used namespaces

using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.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 Enumerations

		/// <summary>
		/// An enumeration of legend cell types.
		/// </summary>
		public enum LegendCellType
		{
			/// <summary>
			/// Legend cell contains text.
			/// </summary>
			Text,

			/// <summary>
			/// Legend cell contains series symbol.
			/// </summary>
			SeriesSymbol,

			/// <summary>
			/// Legend cell contains image.
			/// </summary>
			Image
		}

		/// <summary>
        /// An enumeration of legend cell column types.
		/// </summary>
		public enum LegendCellColumnType
		{
			/// <summary>
			/// Legend column contains text.
			/// </summary>
			Text,

			/// <summary>
			/// Legend column contains series symbol.
			/// </summary>
			SeriesSymbol
		}

		#endregion // Enumerations

		/// <summary>
        /// The LegendCellColumn class represents a cell column in a legend, 
        /// used to extend the functionality of the default legend. It contains 
        /// visual appearance properties, legend header settings and also determine
        /// how and in which order cells are formed for each of the legend items.
		/// </summary>
		[
		SRDescription("DescriptionAttributeLegendCellColumn_LegendCellColumn"),
		]
#if Microsoft_CONTROL
        public class LegendCellColumn : 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 LegendCellColumn : ChartNamedElement, IChartMapArea
#endif //!Microsoft_CONTROL
        {
            #region Fields

			// Legend column type
			private LegendCellColumnType _columnType = LegendCellColumnType.Text;

			// Legend column text
			private string	_text = KeywordName.LegendText;

			// Legend column text color
			private Color	_foreColor = Color.Empty;

			// Legend column back color
			private Color	_backColor = Color.Empty;

            // Font cache
            private FontCache _fontCache = new FontCache();

			// Legend column text font
			private Font	_font = null;

			// Legend column series symbol size
			private Size	_seriesSymbolSize = new Size(200, 70);

			// Legend column content allignment
			private ContentAlignment _alignment = ContentAlignment.MiddleCenter;

			// Legend column tooltip
			private string	_toolTip = string.Empty;

			// Legend column margins
			private Margins	_margins = new Margins(0, 0, 15, 15);

#if !Microsoft_CONTROL

			// Legend column Url
			private string	_url = string.Empty;

			// Legend column map area attribute
			private string _mapAreaAttribute = string.Empty;
            private string _postbackValue = String.Empty;
#endif // !Microsoft_CONTROL

            // Legend column header text
			private string	_headerText = string.Empty;

			// Legend column/cell content allignment
			private StringAlignment _headerAlignment = StringAlignment.Center;

			// Legend column header text color
			private Color	_headerForeColor = Color.Black;

			// Legend column header text back color
			private Color	_headerBackColor = Color.Empty;

			// Legend column header text font
            private Font    _headerFont = null;

			// Minimum column width
			private int		_minimumCellWidth = -1;

			// Maximum column width
			private int		_maximumCellWidth = -1;

			#endregion // Fields

			#region Constructors

			/// <summary>
            /// LegendCellColumn constructor.
			/// </summary>
            public LegendCellColumn()
                : this(string.Empty, LegendCellColumnType.Text, KeywordName.LegendText, ContentAlignment.MiddleCenter)
			{
                _headerFont = _fontCache.DefaultBoldFont;
			}
			

			/// <summary>
            /// LegendCellColumn constructor.
			/// </summary>
			/// <param name="headerText">Column header text.</param>
			/// <param name="columnType">Column type.</param>
			/// <param name="text">Column cell text.</param>
			public LegendCellColumn(string headerText, LegendCellColumnType columnType, string text) :  this(headerText, columnType, text, ContentAlignment.MiddleCenter)
			{
				
			}

			/// <summary>
			/// Legend column object constructor.
			/// </summary>
			/// <param name="headerText">Column header text.</param>
			/// <param name="columnType">Column type.</param>
			/// <param name="text">Column cell text .</param>
			/// <param name="alignment">Column cell content alignment.</param>
			public LegendCellColumn(string headerText, LegendCellColumnType columnType, string text, ContentAlignment alignment)
			{
                this._headerText = headerText;
                this._columnType = columnType;
                this._text = text;
                this._alignment = alignment;
            }


			#endregion // Constructors

			#region Properties

			/// <summary>
			/// Gets or sets name of legend column.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			SRDescription("DescriptionAttributeLegendCellColumn_Name"),
			]
			public override string Name
			{
				get
				{
					return base.Name;
				}
				set
				{
                    base.Name = value;
				}
			}


            /// <summary>
            /// Gets legend this column belongs too.
            /// </summary>
            [
            Browsable(false),
            DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
            SerializationVisibilityAttribute(SerializationVisibility.Hidden),
            ]
            public virtual Legend Legend
            {
                get
                {
                    if (Parent != null)
                        return Parent.Parent as Legend;
                    else
                        return null;
                }
            }


			/// <summary>
			/// Gets or sets legend column type.  This is only applicable to items that are automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(LegendCellColumnType.Text),
			SRDescription("DescriptionAttributeLegendCellColumn_ColumnType"),
			ParenthesizePropertyNameAttribute(true)
			]
			public virtual LegendCellColumnType ColumnType
			{
				get
				{
					return this._columnType;
				}
				set
				{
					this._columnType = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets legend column text.  This is only applicable to items that are automatically generated for the series.  
            /// Set the ColumnType property to text to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(KeywordName.LegendText),
			SRDescription("DescriptionAttributeLegendCellColumn_Text"),
            Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
			]
			public virtual string Text
			{
				get
				{
					return this._text;
				}
				set
				{
					this._text = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the text color of the legend column.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeForeColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color ForeColor
			{
				get
				{
					return this._foreColor;
				}
				set
				{
					this._foreColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the background color of the legend column.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeBackColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color BackColor
			{
				get
				{
					return this._backColor;
				}
				set
				{
					this._backColor = value;
					this.Invalidate();
				}
			}


			/// <summary>
            /// Gets or sets the font of the legend column text.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(null),
			SRDescription("DescriptionAttributeLegendCellColumn_Font"),
			]
			public virtual Font Font
			{
				get
				{
					return this._font;
				}
				set
				{
					this._font = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the series symbol size of the legend column
			/// for the items automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(typeof(Size), "200, 70"),
			SRDescription("DescriptionAttributeLegendCellColumn_SeriesSymbolSize"),
			]
			public virtual Size SeriesSymbolSize
			{
				get
				{
					return this._seriesSymbolSize;
				}
				set
				{
					if(value.Width < 0 || value.Height < 0)
					{
                        throw (new ArgumentException(SR.ExceptionSeriesSymbolSizeIsNegative, "value"));
					}
					this._seriesSymbolSize = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the content alignment of the legend column.
			/// This is only applicable to items that are automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(ContentAlignment.MiddleCenter),
			SRDescription("DescriptionAttributeLegendCellColumn_Alignment"),
			]
			public virtual ContentAlignment Alignment
			{
				get
				{
					return this._alignment;
				}
				set
				{
					this._alignment = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the margins of the legend column (as a percentage of legend font size).  
            /// This is only applicable to items that are automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			DefaultValue(typeof(Margins), "0,0,15,15"),
			SRDescription("DescriptionAttributeLegendCellColumn_Margins"),
			SerializationVisibilityAttribute(SerializationVisibility.Attribute),
			DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
			NotifyParentPropertyAttribute(true),
#if !Microsoft_CONTROL
			PersistenceMode(PersistenceMode.InnerProperty),
#endif
			]
			public virtual Margins Margins
			{
				get
				{
					return this._margins;
				}
				set
				{
					this._margins = value;
					this.Invalidate();

#if Microsoft_CONTROL
					// Set common elements of the new margins class
					if(this.Legend != null)
					{
						this._margins.Common = this.Legend.Common;
					}
#endif // Microsoft_CONTROL
				}
			}

			/// <summary>
			/// Returns true if property should be serialized.  This is for internal use only.
			/// </summary>
			[EditorBrowsableAttribute(EditorBrowsableState.Never)]
			public bool ShouldSerializeMargins()
			{
				if(this._margins.Top == 0 &&
					this._margins.Bottom == 0 &&
					this._margins.Left == 15 &&
					this._margins.Right == 15 )
				{
					return false;
				}
				return true;
			}

			/// <summary>
			/// Gets or sets the legend column tooltip. This is only applicable to items that are automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
            SRDescription("DescriptionAttributeToolTip"),
			DefaultValue(""),
            Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
			]
			public virtual string ToolTip
			{
				set
				{
					this._toolTip = value;
#if Microsoft_CONTROL
					if(Chart != null && 
					   Chart.selection != null)
					{
						Chart.selection.enabledChecked = false;
					}
#endif
				}
				get
				{
					return this._toolTip;
				}
			}

#if !Microsoft_CONTROL

			/// <summary>
			/// Gets or sets the URL target of the legend items automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			SRDescription("DescriptionAttributeUrl"),
			DefaultValue(""),
            Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
			]
			public virtual string Url
			{
				set
				{
					this._url = value;
				}
				get
				{
					return this._url;
				}
			}

			/// <summary>
			/// Gets or sets the other attributes of the legend items automatically generated for the series.
			/// </summary>
			[
			SRCategory("CategoryAttributeSeriesItems"),
			SRDescription("DescriptionAttributeMapAreaAttributes"),
            Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
			DefaultValue(""),
			]
			public virtual string MapAreaAttributes
			{
				set
				{
					this._mapAreaAttribute = value;
				}
				get
				{
					return this._mapAreaAttribute;
				}
			}

            /// <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.CategoryAttributeSeriesItems)]
            [SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
            public string PostBackValue 
            {
                get
                {
                    return this._postbackValue;
                }
                set
                {
                    this._postbackValue = value;
                }
            }


#endif // !Microsoft_CONTROL

            /// <summary>
			/// Gets or sets the legend column header text.
			/// </summary>
			[
			SRCategory("CategoryAttributeHeader"),
			DefaultValue(""),
			SRDescription("DescriptionAttributeLegendCellColumn_HeaderText"),
			]
			public virtual string HeaderText
			{
				get
				{
					return this._headerText;
				}
				set
				{
					this._headerText = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the color of the legend column header text.
			/// </summary>
			[
			SRCategory("CategoryAttributeHeader"),
			DefaultValue(typeof(Color), "Black"),
			SRDescription("DescriptionAttributeLegendCellColumn_HeaderColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color HeaderForeColor
			{
				get
				{
					return this._headerForeColor;
				}
				set
				{
					this._headerForeColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the background color of the legend column header.
			/// </summary>
			[
			SRCategory("CategoryAttributeHeader"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeHeaderBackColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color HeaderBackColor
			{
				get
				{
					return this._headerBackColor;
				}
				set
				{
					this._headerBackColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the font of the legend column header.
			/// </summary>
			[
			SRCategory("CategoryAttributeHeader"),
            DefaultValue(typeof(Font), "Microsoft Sans Serif, 8pt, style=Bold"),
			SRDescription("DescriptionAttributeLegendCellColumn_HeaderFont"),
			]
			public virtual Font HeaderFont
			{
				get
				{
					return this._headerFont;
				}
				set
				{
					this._headerFont = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the horizontal text alignment of the legend column header.
			/// </summary>
			[
			SRCategory("CategoryAttributeHeader"),
			DefaultValue(typeof(StringAlignment), "Center"),
			SRDescription("DescriptionAttributeLegendCellColumn_HeaderTextAlignment"),
			]
			public StringAlignment HeaderAlignment
			{
				get
				{
					return this._headerAlignment;
				}
				set
				{
					if(value != this._headerAlignment)
					{
						this._headerAlignment = value;
						this.Invalidate();
					}
				}
			}

			/// <summary>
			/// Gets or sets the minimum width (as a percentage of legend font size) of legend column. Set this property to -1 for automatic calculation.
			/// </summary>
			[
			SRCategory("CategoryAttributeSize"),
			DefaultValue(-1),
			TypeConverter(typeof(IntNanValueConverter)),
			SRDescription("DescriptionAttributeLegendCellColumn_MinimumWidth"),
			]
			public virtual int MinimumWidth
			{
				get
				{
					return this._minimumCellWidth;
				}
				set
				{
					if(value < -1)
					{
                        throw (new ArgumentException(SR.ExceptionMinimumCellWidthIsWrong, "value"));
					}

					this._minimumCellWidth = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the maximum width (as a percentage of legend font size) of legend column.  Set this property to -1 for automatic calculation.
			/// </summary>
			[
			SRCategory("CategoryAttributeSize"),
			DefaultValue(-1),
			TypeConverter(typeof(IntNanValueConverter)),
			SRDescription("DescriptionAttributeLegendCellColumn_MaximumWidth"),
			]
			public virtual int MaximumWidth
			{
				get
				{
					return this._maximumCellWidth;
				}
				set
				{
					if(value < -1)
					{
                        throw (new ArgumentException(SR.ExceptionMaximumCellWidthIsWrong, "value"));
					}
					this._maximumCellWidth = value;
					this.Invalidate();
				}
			}

			#endregion // Properties
			
			#region Methods

			/// <summary>
			/// Creates a new LegendCell object and copies all properties from the 
			/// current column into the newly created one.
			/// </summary>
			/// <returns>A new copy of the LegendCell</returns>
			internal LegendCell CreateNewCell()
			{
				LegendCell newCell = new LegendCell();
				newCell.CellType = (this.ColumnType == LegendCellColumnType.SeriesSymbol) ? LegendCellType.SeriesSymbol : LegendCellType.Text;
				newCell.Text = this.Text;
				newCell.ToolTip = this.ToolTip;
#if !Microsoft_CONTROL
				newCell.Url = this.Url;
				newCell.MapAreaAttributes = this.MapAreaAttributes;
                newCell.PostBackValue = this.PostBackValue;
#endif // !Microsoft_CONTROL

				newCell.SeriesSymbolSize = this.SeriesSymbolSize;
				newCell.Alignment = this.Alignment;
				newCell.Margins = new Margins(this.Margins.Top, this.Margins.Bottom, this.Margins.Left, this.Margins.Right);
				return newCell;
			}

			#endregion // Methods

            #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 (_fontCache != null)
                    {
                        _fontCache.Dispose();
                        _fontCache = null;
                    }
                }
            }


            #endregion
		}

		/// <summary>
        /// The LegendCell class represents a single cell in the chart legend. 
        /// Legend contains several legend items.  Each item contains several
        /// cells which form the vertical columns. This class provides properties 
        /// which determine content of the cell and its visual appearance. It
        /// also contains method which determine the size of the cell and draw
        /// cell in the chart.
		/// </summary>
		[
		SRDescription("DescriptionAttributeLegendCell_LegendCell"),
		]
#if Microsoft_CONTROL
        public class LegendCell  : 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 LegendCell : ChartNamedElement, IChartMapArea
#endif
        {
            #region Fields

			// Legend cell type
			private LegendCellType _cellType = LegendCellType.Text;

			// Legend cell text
			private string	_text = string.Empty;

			// Legend cell text color
			private Color	_foreColor = Color.Empty;

			// Legend cell back color
			private Color	_backColor = Color.Empty;

            // Font cache
            private FontCache _fontCache = new FontCache();

            // Legend cell text font
			private Font	_font = null;

			// Legend cell image name
			private string	_image = string.Empty;

			// Legend cell image transparent color
			private Color	_imageTransparentColor = Color.Empty;

			// Legend cell image size
			private Size	_imageSize = Size.Empty;

			// Legend cell series symbol size
			private Size	_seriesSymbolSize = new Size(200, 70);

			// Legend cell content allignment
			private ContentAlignment _alignment = ContentAlignment.MiddleCenter;

			// Numer of cells this cell uses to show it's content
			private int		_cellSpan = 1;

			// Legend cell tooltip
			private string	_toolTip = string.Empty;

			// Legend cell margins
			private Margins	_margins = new Margins(0, 0, 15, 15);

			// Cell row index
			private int _rowIndex = -1;

#if !Microsoft_CONTROL

			// Legend cell Url
			private string	_url = string.Empty;

			// Legend cell map area attribute
			private string _mapAreaAttribute = string.Empty;
            private string _postbackValue = String.Empty;

#endif // !Microsoft_CONTROL

            // Position where cell is drawn in pixel coordinates.
			// Exncludes margins and space required for separators
			internal Rectangle	cellPosition = Rectangle.Empty;

			// Position where cell is drawn in pixel coordinates. 
			// Includes margins and space required for separators
			internal Rectangle	cellPositionWithMargins = Rectangle.Empty;

			// Last cached cell size.
			private Size _cachedCellSize = Size.Empty;

			// Font reduced value used to calculate last cached cell size
			private int _cachedCellSizeFontReducedBy = 0;

            #endregion // Fields

            #region Constructors

            /// <summary>
            /// LegendCell constructor.
			/// </summary>
			public LegendCell()
			{
				this.Intitialize(LegendCellType.Text, string.Empty, ContentAlignment.MiddleCenter);
			}

			/// <summary>
            /// LegendCell constructor.
			/// </summary>
			/// <param name="text">Cell text or image name, depending on the type.</param>
			public LegendCell(string text)
			{
				this.Intitialize(LegendCellType.Text, text, ContentAlignment.MiddleCenter);
			}

			/// <summary>
            /// LegendCell constructor.
			/// </summary>
			/// <param name="cellType">Cell type.</param>
			/// <param name="text">Cell text or image name, depending on the type.</param>
			public LegendCell(LegendCellType cellType, string text)
			{
				this.Intitialize(cellType, text, ContentAlignment.MiddleCenter);
			}

			/// <summary>
            /// LegendCell constructor.
			/// </summary>
			/// <param name="cellType">Cell type.</param>
			/// <param name="text">Cell text or image name, depending on the type.</param>
			/// <param name="alignment">Cell content alignment.</param>
			public LegendCell(LegendCellType cellType, string text, ContentAlignment alignment)
			{
				this.Intitialize(cellType, text, alignment);
			}

			/// <summary>
			/// Initializes newly created object.
			/// </summary>
			/// <param name="cellType">Cell type.</param>
			/// <param name="text">Cell text or image name depending on the type.</param>
			/// <param name="alignment">Cell content alignment.</param>
			private void Intitialize(LegendCellType cellType, string text, ContentAlignment alignment)
			{
				this._cellType = cellType;
				if(this._cellType == LegendCellType.Image)
				{
					this._image = text;
				}
				else
				{
					this._text = text;
				}
				this._alignment = alignment;
#if !Microsoft_CONTROL
                this.PostBackValue = String.Empty;
#endif //!WIN_CONTROL
            }

			#endregion // Constructors

			#region Properties

			/// <summary>
			/// Gets or sets the name of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			SRDescription("DescriptionAttributeLegendCell_Name"),
			]
			public override string Name
			{
				get
				{
					return base.Name;
				}
				set
				{
                    base.Name = value;
				}
			}

			/// <summary>
			/// Gets or sets the type of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(LegendCellType.Text),
			SRDescription("DescriptionAttributeLegendCell_CellType"),
			ParenthesizePropertyNameAttribute(true)
			]
			public virtual LegendCellType CellType
			{
				get
				{
					return this._cellType;
				}
				set
				{
					this._cellType = value;
					this.Invalidate();
				}
			}

            /// <summary>
            /// Gets legend this column/cell belongs too.
            /// </summary>
            [
            Browsable(false),
            DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
            SerializationVisibilityAttribute(SerializationVisibility.Hidden),
            ]
            public virtual Legend Legend
            {
                get
                {
                    LegendItem item = this.LegendItem;
                    if (item != null)
                        return item.Legend;
                    else
                        return null;
                }
            }

            /// <summary>
            /// Gets legend item this cell belongs too.
            /// </summary>
            [
            Browsable(false),
            DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
            SerializationVisibilityAttribute(SerializationVisibility.Hidden),
            ]
            public virtual LegendItem LegendItem
            {
                get
                {
                    if (Parent != null)
                        return Parent.Parent as LegendItem;
                    else
                        return null;
                }
            }



			/// <summary>
			/// Gets or sets the text of the legend cell. Set CellType to text to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(""),
			SRDescription("DescriptionAttributeLegendCell_Text"),
			]
			public virtual string Text
			{
				get
				{
					return this._text;
				}
				set
				{
					this._text = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the text color of the legend cell. Set CellType to text to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeForeColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color ForeColor
			{
				get
				{
					return this._foreColor;
				}
				set
				{
					this._foreColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the background color of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeBackColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color BackColor
			{
				get
				{
					return this._backColor;
				}
				set
				{
					this._backColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the font of the legend cell. Set CellType to text to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(null),
			SRDescription("DescriptionAttributeLegendCell_Font"),
			]
			public virtual Font Font
			{
				get
				{
                    return this._font;
				}
				set
				{
                    this._font = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the URL of the image of the legend cell. Set CellType to image to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(""),
			SRDescription("DescriptionAttributeLegendCell_Image"),
            Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
			]
			public virtual string Image
			{
				get
				{
					return this._image;
				}
				set
				{
					this._image = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets a color which will be replaced with a transparent color while drawing the image.  Set CellType to image to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeAppearance"),
			DefaultValue(typeof(Color), ""),
            SRDescription("DescriptionAttributeImageTransparentColor"),
            TypeConverter(typeof(ColorConverter)),
            Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
			]
			public virtual Color ImageTransparentColor
			{
				get
				{
					return this._imageTransparentColor;
				}
				set
				{
					this._imageTransparentColor = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the image size (as a percentage of legend font size) of the legend cell. 
            /// Set CellType to Image to use this property.
			/// </summary>
			/// <remarks>
			/// If property is set to Size.IsEmpty, the original image pixels size is used.
			/// </remarks>
			[
			SRCategory("CategoryAttributeLayout"),
			DefaultValue(typeof(Size), "0, 0"),
			TypeConverter(typeof(SizeEmptyValueConverter)),
			SRDescription("DescriptionAttributeLegendCell_ImageSize"),
			]
			public virtual Size ImageSize
			{
				get
				{
					return this._imageSize;
				}
				set
				{
					if(value.Width < 0 || value.Height < 0)
					{
                        throw (new ArgumentException(SR.ExceptionLegendCellImageSizeIsNegative, "value"));
					}
					this._imageSize = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the series symbol size (as a percentage of legend font size) of the legend cell. 
            /// Set CellType to SeriesSymbol to use this property.
			/// </summary>
			[
			SRCategory("CategoryAttributeLayout"),
			DefaultValue(typeof(Size), "200, 70"),
			SRDescription("DescriptionAttributeLegendCell_SeriesSymbolSize"),
			]
			public virtual Size SeriesSymbolSize
			{
				get
				{
					return this._seriesSymbolSize;
				}
				set
				{
					if(value.Width < 0 || value.Height < 0)
					{
                        throw (new ArgumentException(SR.ExceptionLegendCellSeriesSymbolSizeIsNegative, "value"));
					}
					this._seriesSymbolSize = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the content alignment of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeLayout"),
			DefaultValue(ContentAlignment.MiddleCenter),
			SRDescription("DescriptionAttributeLegendCell_Alignment"),
			]
			public virtual ContentAlignment Alignment
			{
				get
				{
					return this._alignment;
				}
				set
				{
					this._alignment = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the number of horizontal cells used to draw the content.
			/// </summary>
			[
			SRCategory("CategoryAttributeLayout"),
			DefaultValue(1),
			SRDescription("DescriptionAttributeLegendCell_CellSpan"),
			]
			public virtual int CellSpan
			{
				get
				{
					return this._cellSpan;
				}
				set
				{
					if(value < 1)
					{
                        throw (new ArgumentException(SR.ExceptionLegendCellSpanIsLessThenOne, "value"));
					}
					this._cellSpan = value;
					this.Invalidate();
				}
			}

			/// <summary>
			/// Gets or sets the legend cell margins (as a percentage of legend font size).
			/// </summary>
			[
			SRCategory("CategoryAttributeLayout"),
			DefaultValue(typeof(Margins), "0,0,15,15"),
			SRDescription("DescriptionAttributeLegendCell_Margins"),
			SerializationVisibilityAttribute(SerializationVisibility.Attribute),
			NotifyParentPropertyAttribute(true),
#if !Microsoft_CONTROL
			PersistenceMode(PersistenceMode.InnerProperty),
#endif
			]
			public virtual Margins Margins
			{
				get
				{
					return this._margins;
				}
				set
				{
					this._margins = value;
					this.Invalidate();

#if Microsoft_CONTROL
					// Set common elements of the new margins class
					if(this.Legend != null)
					{
						this._margins.Common = this.Common;
					}
#endif // Microsoft_CONTROL
				}
			}

			/// <summary>
			/// Returns true if property should be serialized.  This method is for internal use only.
			/// </summary>
			[EditorBrowsableAttribute(EditorBrowsableState.Never)]
			internal bool ShouldSerializeMargins()
			{
				if(this._margins.Top == 0 &&
					this._margins.Bottom == 0 &&
					this._margins.Left == 15 &&
					this._margins.Right == 15 )
				{
					return false;
				}
				return true;
			}

			/// <summary>
			/// Gets or sets the tooltip of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeMapArea"),
            SRDescription("DescriptionAttributeToolTip"),
			DefaultValue(""),
			]
			public virtual string ToolTip
			{
				set
				{
					this._toolTip = value;
#if Microsoft_CONTROL
					if(this.Chart != null && 
					   this.Chart.selection != null)
					{
						this.Chart.selection.enabledChecked = false;
					}
#endif
				}
				get
				{
					return this._toolTip;
				}
			}
			
#if !Microsoft_CONTROL

			/// <summary>
            /// Gets or sets the URL target of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeMapArea"),
			SRDescription("DescriptionAttributeUrl"),
			DefaultValue(""),
            Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base)
			]
			public virtual string Url
			{
				set
				{
					this._url = value;
				}
				get
				{
					return this._url;
				}
			}

			/// <summary>
            /// Gets or sets the other map area attributes of the legend cell.
			/// </summary>
			[
			SRCategory("CategoryAttributeMapArea"),
			SRDescription("DescriptionAttributeMapAreaAttributes"),
			DefaultValue(""),
			]
			public virtual string MapAreaAttributes
			{
				set
				{
					this._mapAreaAttribute = value;
				}
				get
				{
					return this._mapAreaAttribute;
				}
			}

            /// <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 // Properties

            #region Methods

            /// <summary>
			/// Resets cached cell values.
			/// </summary>
			internal void ResetCache()
			{
				this._cachedCellSize = Size.Empty;
				this._cachedCellSizeFontReducedBy = 0;
			}

			/// <summary>
			/// Sets cell position in relative coordinates.
			/// </summary>
			/// <param name="rowIndex">Cell row index.</param>
			/// <param name="position">Cell position.</param>
			/// <param name="singleWCharacterSize">Size of the 'W' character used to calculate elements.</param>
			internal void SetCellPosition(
				int rowIndex,
				Rectangle position, 
				Size singleWCharacterSize)
			{
				// Set cell position 
				this.cellPosition = position;
				this.cellPositionWithMargins = position;
				this._rowIndex = rowIndex;

				// Adjust cell position by specified margin
				this.cellPosition.X += (int)(this.Margins.Left * singleWCharacterSize.Width / 100f);
				this.cellPosition.Y += (int)(this.Margins.Top * singleWCharacterSize.Height / 100f);
				this.cellPosition.Width -= (int)(this.Margins.Left * singleWCharacterSize.Width / 100f)
					+ (int)(this.Margins.Right * singleWCharacterSize.Width / 100f);
				this.cellPosition.Height -= (int)(this.Margins.Top * singleWCharacterSize.Height / 100f)
					+ (int)(this.Margins.Bottom * singleWCharacterSize.Height / 100f);

				// Adjust cell position by space required for the separatorType
				if( LegendItem != null && 
					LegendItem.SeparatorType != LegendSeparatorStyle.None)
				{
					this.cellPosition.Height -= this.Legend.GetSeparatorSize(LegendItem.SeparatorType).Height;
				}
			}

			/// <summary>
			/// Measures legend cell size in chart relative coordinates.
			/// </summary>
			/// <param name="graph">
			/// Chart graphics.
			/// </param>
			/// <param name="fontSizeReducedBy">
			/// A positive or negative integer value that determines the how standard cell font size
			/// should be adjusted. As a result smaller or larger font can be used.
			/// </param>
			/// <param name="legendAutoFont">
			/// Auto fit font used in the legend.
			/// </param>
			/// <param name="singleWCharacterSize">
			/// Size of the 'W' character used to calculate elements.
			/// </param>
			/// <returns>Legend cell size.</returns>
            internal Size MeasureCell(
				ChartGraphics graph, 
				int fontSizeReducedBy,
				Font legendAutoFont,
				Size singleWCharacterSize)
			{
				// Check if cached size may be reused
				if(this._cachedCellSizeFontReducedBy == fontSizeReducedBy &&
					!this._cachedCellSize.IsEmpty)
				{
					return this._cachedCellSize;
				}

				// Get cell font
				Size cellSize = Size.Empty;
				bool disposeFont = false;
				Font cellFont = this.GetCellFont(legendAutoFont, fontSizeReducedBy, out disposeFont);
			
				// Measure cell content size based on the type
				if(this.CellType == LegendCellType.SeriesSymbol)
				{
					cellSize.Width = (int)(Math.Abs(this.SeriesSymbolSize.Width) * singleWCharacterSize.Width / 100f);
					cellSize.Height = (int)(Math.Abs(this.SeriesSymbolSize.Height) * singleWCharacterSize.Height / 100f);
				}
				else if(this.CellType == LegendCellType.Image)
				{
					if(this.ImageSize.IsEmpty && this.Image.Length > 0)
					{
                        SizeF imageSize = new SizeF();

						// Use original image size
                        if (this.Common.ImageLoader.GetAdjustedImageSize(this.Image, graph.Graphics, ref imageSize))
                        {
                            cellSize.Width = (int)imageSize.Width;
                            cellSize.Height = (int)imageSize.Height;
                        }
					}
					else
					{
						cellSize.Width = (int)(Math.Abs(this.ImageSize.Width) * singleWCharacterSize.Width / 100f);
						cellSize.Height = (int)(Math.Abs(this.ImageSize.Height) * singleWCharacterSize.Height / 100f);
					}
				}
				else if(this.CellType == LegendCellType.Text)
				{
					// Get current cell text taking in consideration keywords
					// and automatic text wrapping.
					string cellText = this.GetCellText();

					// Measure text size.
					// Note that extra "I" character added to add more horizontal spacing
					cellSize =  graph.MeasureStringAbs(cellText + "I", cellFont);
				}
				else
				{
                    throw (new InvalidOperationException(SR.ExceptionLegendCellTypeUnknown(this.CellType.ToString())));
				}

				// Add cell margins 
				cellSize.Width += (int)((this.Margins.Left + this.Margins.Right) * singleWCharacterSize.Width / 100f);
				cellSize.Height += (int)((this.Margins.Top + this.Margins.Bottom) * singleWCharacterSize.Height / 100f);

				// Add space required for the separatorType
				if( LegendItem != null && 
					LegendItem.SeparatorType != LegendSeparatorStyle.None)
				{
					cellSize.Height += this.Legend.GetSeparatorSize(LegendItem.SeparatorType).Height;
				}

				// Dispose created font object
				if(disposeFont)
				{
					cellFont.Dispose();
					cellFont = null;
				}

				// Save calculated size
				this._cachedCellSize = cellSize;
				this._cachedCellSizeFontReducedBy = fontSizeReducedBy;

				return cellSize;
			}

			/// <summary>
			/// Gets cell background color.
			/// </summary>
			/// <returns></returns>
			private Color GetCellBackColor()
			{
				Color resultColor = this.BackColor;
				if(this.BackColor.IsEmpty && this.Legend != null)
				{
					// Try getting back color from the associated column
					if(this.LegendItem != null)
					{
						// Get index of this cell
						int cellIndex = this.LegendItem.Cells.IndexOf(this);
						if(cellIndex >= 0)
						{
							// Check if associated column exsists
							if(cellIndex < this.Legend.CellColumns.Count && 
								!this.Legend.CellColumns[cellIndex].BackColor.IsEmpty)
							{
								resultColor = this.Legend.CellColumns[cellIndex].BackColor;
							}
						}
					}

					// Get font from the legend isInterlaced 
					if(resultColor.IsEmpty && 
						this.Legend.InterlacedRows &&
						this._rowIndex % 2 != 0)
					{
						if(this.Legend.InterlacedRowsColor.IsEmpty)
						{
							// Automatically determine background color
							// If isInterlaced strips color is not set - use darker color of the area
							if(this.Legend.BackColor == Color.Empty)
							{
								resultColor = Color.LightGray;
							}
							else if(this.Legend.BackColor == Color.Transparent)
							{
								if(Chart.BackColor != Color.Transparent && 
									Chart.BackColor != Color.Black)
								{
									resultColor = ChartGraphics.GetGradientColor( Chart.BackColor, Color.Black, 0.2 );
								}
								else
								{
									resultColor = Color.LightGray;
								}
							}
							else
							{
								resultColor = ChartGraphics.GetGradientColor( this.Legend.BackColor, Color.Black, 0.2 );
							}
						}
						else
						{
							resultColor = this.Legend.InterlacedRowsColor;
						}
					}
				}
				return resultColor;
			}

			/// <summary>
			/// Gets default cell font. Font can be specified in the cell, column or in the legend.
			/// </summary>
			/// <param name="legendAutoFont">Auto fit font used in the legend.</param>
			/// <param name="fontSizeReducedBy">Number of points legend auto-font reduced by.</param>
			/// <param name="disposeFont">Returns a flag if result font object should be disposed.</param>
			/// <returns>Default cell font.</returns>
			private Font GetCellFont(Font legendAutoFont, int fontSizeReducedBy, out bool disposeFont)
			{
				Font cellFont = this.Font;
				disposeFont = false;

				// Check if font is not set in the cell and legend object reference is valid
				if(cellFont == null && 
					this.Legend != null)
				{
					// Try getting font from the associated column
					if(this.LegendItem != null)
					{
						// Get index of this cell
						int cellIndex = this.LegendItem.Cells.IndexOf(this);
						if(cellIndex >= 0)
						{
							// Check if associated column exsists
							if(cellIndex < this.Legend.CellColumns.Count && 
								this.Legend.CellColumns[cellIndex].Font != null)
							{
								cellFont = this.Legend.CellColumns[cellIndex].Font;
							}
						}
					}

					// Get font from the legend
					if(cellFont == null)
					{
						cellFont = legendAutoFont;

						// No further processing required.
						// Font is already reduced.
						return cellFont;
					}
				}

				// Check if font size should be adjusted
				if(cellFont != null && fontSizeReducedBy != 0)
				{
					// New font is created anf it must be disposed
					disposeFont = true;

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

					// Create new font
					cellFont = new Font(
						cellFont.FontFamily, 
						newFontSize, 
						cellFont.Style, 
						cellFont.Unit);
				}

				return cellFont;
			}

			/// <summary>
			/// Helper function that returns cell tooltip.
			/// </summary>
			/// <remarks>
			/// Tooltip can be set in the cell or in the legend item. Cell 
			/// tooltip always has a higher priority.
			/// </remarks>
			/// <returns>Returns cell text.</returns>
			private string GetCellToolTip()
			{
				// Check if tooltip is set in the cell (highest priority)
				if(this.ToolTip.Length > 0)
				{
					return this.ToolTip;
				}

				// Check if tooltip is set in associated legend item
				if(this.LegendItem != null)
				{
					return this.LegendItem.ToolTip;
				}

				return string.Empty;
			}

			/// <summary>
			/// Helper function that returns cell url.
			/// </summary>
			/// <remarks>
			/// Url can be set in the cell or in the legend item. Cell 
			/// tooltip always has a higher priority.
			/// </remarks>
			/// <returns>Returns cell text.</returns>
			private string GetCellUrl()
			{
#if !Microsoft_CONTROL
				// Check if tooltip is set in the cell (highest priority)
				if(this._url.Length > 0)
				{
					return this._url;
				}

				// Check if tooltip is set in associated legend item
				if(this.LegendItem != null)
				{
                    return this.LegendItem.Url;
				}
#endif // !Microsoft_CONTROL
				return string.Empty;
			}

			/// <summary>
			/// Helper function that returns cell url.
			/// </summary>
			/// <remarks>
			/// Url can be set in the cell or in the legend item. Cell 
			/// tooltip always has a higher priority.
			/// </remarks>
			/// <returns>Returns cell text.</returns>
			private string GetCellMapAreaAttributes()
			{
#if !Microsoft_CONTROL
				// Check if tooltip is set in the cell (highest priority)
				if(this._mapAreaAttribute.Length > 0)
				{
					return this._mapAreaAttribute;
				}

				// Check if tooltip is set in associated legend item
				if(this.LegendItem != null)
				{
					return this.LegendItem.MapAreaAttributes;
				}
#endif // !Microsoft_CONTROL
				return string.Empty;
			}

            /// <summary>
            /// Helper function that returns cell url.
            /// </summary>
            /// <remarks>
            /// Url can be set in the cell or in the legend item. Cell 
            /// tooltip always has a higher priority.
            /// </remarks>
            /// <returns>Returns cell text.</returns>
            private string GetCellPostBackValue()
            {
#if !Microsoft_CONTROL
                // Check if tooltip is set in the cell (highest priority)
                if (this._postbackValue.Length > 0)
                {
                    return this._postbackValue;
                }

                // Check if tooltip is set in associated legend item
                if (this.LegendItem != null)
                {
                    return this.LegendItem.PostBackValue;
                }
#endif // !Microsoft_CONTROL
                return string.Empty;
            }

			/// <summary>
			/// Helper function that returns the exact text presented in the cell.
			/// </summary>
			/// <remarks>
			/// This method replaces the "\n" substring with the new line character 
			/// and automatically wrap text if required.
			/// </remarks>
			/// <returns>Returns cell text.</returns>
			private string GetCellText()
			{
				// Replace all "\n" strings with the new line character
				string resultString = this.Text.Replace("\\n", "\n");

				// Replace the KeywordName.LegendText keyword with legend item Name property
				if(this.LegendItem != null)
				{
					resultString = resultString.Replace(KeywordName.LegendText, this.LegendItem.Name);
				}
				else
				{
					resultString = resultString.Replace(KeywordName.LegendText, "");
				}

				// Check if text width exceeds recomended character length
				if(this.Legend != null)
				{
					int recomendedTextLength = this.Legend.TextWrapThreshold;

					if(recomendedTextLength > 0 &&
						resultString.Length > recomendedTextLength)
					{
						// Iterate through all text characters
						int lineLength = 0;
						for(int charIndex = 0; charIndex < resultString.Length; charIndex++)
						{
							// Reset line length when new line character is found
							if(resultString[charIndex] == '\n')
							{
								lineLength = 0;
								continue;
							}

							// Increase line length counter
							++lineLength;

							// Check if current character is a white space and
							// current line length exceeds the recomended values.
							if(char.IsWhiteSpace(resultString, charIndex) &&
								lineLength >= recomendedTextLength)
							{
								// Insert new line character in the string
								lineLength = 0;
								resultString = resultString.Substring(0, charIndex) + "\n" + 
									resultString.Substring(charIndex + 1).TrimStart();
							}
						}
					}
				}

				return resultString;
			}

			/// <summary>
			/// Helper function that returns cell text color.
			/// </summary>
			/// <returns>Cell text color.</returns>
			private Color GetCellForeColor()
			{
				// Check if cell text color defined in the cell
				if(!this.ForeColor.IsEmpty)
				{
					return this.ForeColor;
				}

				// Check if color from the Column or legend should be used
				if(this.Legend != null)
				{
					// Try getting font from the associated column
					if(this.LegendItem != null)
					{
						// Get index of this cell
						int cellIndex = this.LegendItem.Cells.IndexOf(this);
						if(cellIndex >= 0)
						{
							// Check if associated column exsists
							if(cellIndex < this.Legend.CellColumns.Count && 
								!this.Legend.CellColumns[cellIndex].ForeColor.IsEmpty)
							{
								return this.Legend.CellColumns[cellIndex].ForeColor;
							}
						}
					}

					// Use legend text color
					return this.Legend.ForeColor;
				}

				return Color.Black;
			}

			#endregion // Methods

			#region Cell Painting Methods

			/// <summary>
			/// Paints content of the legend cell.
			/// </summary>
			/// <param name="chartGraph">Chart graphics to draw content on.</param>
			/// <param name="fontSizeReducedBy">Number that determines how much the cell font should be reduced by.</param>
			/// <param name="legendAutoFont">Auto-fit font used in the legend.</param>
			/// <param name="singleWCharacterSize">Size of the 'W' character in auto-fit font.</param>
			internal void Paint(
				ChartGraphics chartGraph, 
				int fontSizeReducedBy,
				Font legendAutoFont,
				Size singleWCharacterSize)
			{
				// Check cell size before painting
				if(this.cellPosition.Width <= 0 || this.cellPosition.Height <= 0)
				{
					return;
				}

				// Chart elements painting mode
				if( this.Common.ProcessModePaint )
				{
					// Check if cell background should be painted
					Color cellBackColor = this.GetCellBackColor();
					RectangleF rectRelative = chartGraph.GetRelativeRectangle(this.cellPositionWithMargins);
					if(!cellBackColor.IsEmpty)
					{
						chartGraph.FillRectangleRel( 
							rectRelative, 
							cellBackColor, 
							ChartHatchStyle.None,
							string.Empty,
							ChartImageWrapMode.Tile, 
							Color.Empty,
							ChartImageAlignmentStyle.Center,
							GradientStyle.None, 
							Color.Empty,
							Color.Empty, 
							0, 
							ChartDashStyle.NotSet, 
							Color.Empty, 
							0,
							PenAlignment.Inset);
					}

					// Fire an event for custom cell back drawing
                    this.Chart.CallOnPrePaint(new ChartPaintEventArgs(this, chartGraph, this.Common, new ElementPosition(rectRelative.X, rectRelative.Y, rectRelative.Width, rectRelative.Height)));

					// Check legend cell type
					switch(this.CellType)
					{
						case(LegendCellType.Text):
							this.PaintCellText(chartGraph, fontSizeReducedBy, legendAutoFont);
							break;
						case(LegendCellType.Image):
							this.PaintCellImage(chartGraph, singleWCharacterSize);
							break;
						case(LegendCellType.SeriesSymbol):
							this.PaintCellSeriesSymbol(chartGraph, singleWCharacterSize);
							break;
						default:
                            				throw (new InvalidOperationException(SR.ExceptionLegendCellTypeUnknown(this.CellType.ToString())));
					}

					// Fire an event for custom cell drawing
                    this.Chart.CallOnPostPaint(new ChartPaintEventArgs(this, chartGraph, this.Common, new ElementPosition(rectRelative.X, rectRelative.Y, rectRelative.Width, rectRelative.Height)));
				}
#if DEBUG
				// Draw bounding rectangle for debug purpose
//				RectangleF absRectangle = this.cellPosition;
//				chartGraph.DrawRectangle(Pens.Red, absRectangle.X, absRectangle.Y, absRectangle.Width, absRectangle.Height);
#endif // DEBUG

				// Legend cell selection mode
				if( this.Common.ProcessModeRegions )
				{
					// Add hot region.
					// Note that legend cell is passed as sub-object of legend item
					this.Common.HotRegionsList.AddHotRegion(
						chartGraph.GetRelativeRectangle(this.cellPositionWithMargins),
						this.GetCellToolTip(),
						this.GetCellUrl(),
						this.GetCellMapAreaAttributes(),
                        this.GetCellPostBackValue(),
						this.LegendItem,
						this,
						ChartElementType.LegendItem,
						this.LegendItem.SeriesName);
				}
			}

			/// <summary>
			/// Draw legend cell text.
			/// </summary>
			/// <param name="chartGraph">Chart graphics to draw the text on.</param>
			/// <param name="fontSizeReducedBy">Number that determines how much the cell font should be reduced by.</param>
			/// <param name="legendAutoFont">Auto-fit font used in the legend.</param>
			private void PaintCellText(
				ChartGraphics chartGraph, 
				int fontSizeReducedBy,
				Font legendAutoFont)
			{
				// Get cell font
				bool disposeFont = false;
				Font cellFont = this.GetCellFont(legendAutoFont, fontSizeReducedBy, out disposeFont);

				// Start Svg Selection mode
				chartGraph.StartHotRegion( this.GetCellUrl(), this.GetCellToolTip() );

				// Create font brush
				using(SolidBrush fontBrush = new SolidBrush(this.GetCellForeColor()))
				{
					// Create cell text format
                    using (StringFormat format = new StringFormat(StringFormat.GenericDefault))
                    {
                        format.FormatFlags = StringFormatFlags.LineLimit;
                        format.Trimming = StringTrimming.EllipsisCharacter;
                        format.Alignment = StringAlignment.Center;
                        if (this.Alignment == ContentAlignment.BottomLeft ||
                            this.Alignment == ContentAlignment.MiddleLeft ||
                            this.Alignment == ContentAlignment.TopLeft)
                        {
                            format.Alignment = StringAlignment.Near;
                        }
                        else if (this.Alignment == ContentAlignment.BottomRight ||
                            this.Alignment == ContentAlignment.MiddleRight ||
                            this.Alignment == ContentAlignment.TopRight)
                        {
                            format.Alignment = StringAlignment.Far;
                        }
                        format.LineAlignment = StringAlignment.Center;
                        if (this.Alignment == ContentAlignment.BottomCenter ||
                            this.Alignment == ContentAlignment.BottomLeft ||
                            this.Alignment == ContentAlignment.BottomRight)
                        {
                            format.LineAlignment = StringAlignment.Far;
                        }
                        else if (this.Alignment == ContentAlignment.TopCenter ||
                            this.Alignment == ContentAlignment.TopLeft ||
                            this.Alignment == ContentAlignment.TopRight)
                        {
                            format.LineAlignment = StringAlignment.Near;
                        }

                        // Measure string height out of one character
                        SizeF charSize = chartGraph.MeasureStringAbs(this.GetCellText(), cellFont, new SizeF(10000f, 10000f), format);

                        // If height of one characte is more than rectangle heigjt - remove LineLimit flag
                        if (charSize.Height > this.cellPosition.Height && (format.FormatFlags & StringFormatFlags.LineLimit) != 0)
                        {
                            format.FormatFlags ^= StringFormatFlags.LineLimit;
                        }

                        else if (charSize.Height < this.cellPosition.Height && (format.FormatFlags & StringFormatFlags.LineLimit) == 0)
                        {
                            format.FormatFlags |= StringFormatFlags.LineLimit;
                        }

                        // Draw text
                        chartGraph.DrawStringRel(
                            this.GetCellText(),
                            cellFont,
                            fontBrush,
                            chartGraph.GetRelativeRectangle(this.cellPosition),
                            format);
                    }
				}

				// End Svg Selection mode
				chartGraph.EndHotRegion( );

				// Dispose created cell font object
				if(disposeFont)
				{
					cellFont.Dispose();
					cellFont = null;
				}
			}

			/// <summary>
			/// Paints cell image.
			/// </summary>
			/// <param name="chartGraph">Graphics used to draw cell image.</param>
			/// <param name="singleWCharacterSize">Size of the 'W' character in auto-fit font.</param>
			private void PaintCellImage(
				ChartGraphics chartGraph, 
				Size singleWCharacterSize)
			{
				if(this.Image.Length > 0)
				{
					// Get image size in relative coordinates
					Rectangle	imagePosition = Rectangle.Empty;
                    System.Drawing.Image image = this.Common.ImageLoader.LoadImage(this.Image);
                                        
                    SizeF imageSize = new SizeF();

                    ImageLoader.GetAdjustedImageSize(image, chartGraph.Graphics, ref imageSize);

                    imagePosition.Width = (int)imageSize.Width;
                    imagePosition.Height = (int)imageSize.Height;

					// Calculate cell position
					Rectangle imageCellPosition = this.cellPosition;
					imageCellPosition.Width = imagePosition.Width;
					imageCellPosition.Height = imagePosition.Height;
					if(!this.ImageSize.IsEmpty)
					{
						// Adjust cell size using image symbol size specified
						if(this.ImageSize.Width > 0)
						{
							int newWidth = (int)(this.ImageSize.Width * singleWCharacterSize.Width / 100f);
							if(newWidth > this.cellPosition.Width)
							{
								newWidth = this.cellPosition.Width;
							}
							imageCellPosition.Width = newWidth;
						}
						if(this.ImageSize.Height > 0)
						{
							int newHeight = (int)(this.ImageSize.Height * singleWCharacterSize.Height / 100f);
							if(newHeight > this.cellPosition.Height)
							{
								newHeight = this.cellPosition.Height;
							}
							imageCellPosition.Height = newHeight;
						}
					}

					// Make sure image size fits into the cell drawing rectangle
					float	scaleValue = 1f;
					if(imagePosition.Height > imageCellPosition.Height)
					{
						scaleValue = (float)imagePosition.Height / (float)imageCellPosition.Height;
					}
					if(imagePosition.Width > imageCellPosition.Width)
					{
						scaleValue = Math.Max(scaleValue, (float)imagePosition.Width / (float)imageCellPosition.Width);
					}

					// Scale image size
					imagePosition.Height = (int)(imagePosition.Height / scaleValue);
					imagePosition.Width = (int)(imagePosition.Width / scaleValue);

					// Get image location
					imagePosition.X = (int)((this.cellPosition.X + this.cellPosition.Width/2f) - imagePosition.Width/2f);
					imagePosition.Y = (int)((this.cellPosition.Y + this.cellPosition.Height/2f) - imagePosition.Height/2f);

					// Adjust image location based on the cell content alignment
					if(this.Alignment == ContentAlignment.BottomLeft || 
						this.Alignment == ContentAlignment.MiddleLeft ||
						this.Alignment == ContentAlignment.TopLeft)
					{
						imagePosition.X = this.cellPosition.X;
					}
					else if(this.Alignment == ContentAlignment.BottomRight || 
						this.Alignment == ContentAlignment.MiddleRight ||
						this.Alignment == ContentAlignment.TopRight)
					{
						imagePosition.X = this.cellPosition.Right - imagePosition.Width;
					}
					
					if(this.Alignment == ContentAlignment.BottomCenter || 
						this.Alignment == ContentAlignment.BottomLeft ||
						this.Alignment == ContentAlignment.BottomRight)
					{
						imagePosition.Y = this.cellPosition.Bottom - imagePosition.Height;
					}
					else if(this.Alignment == ContentAlignment.TopCenter || 
						this.Alignment == ContentAlignment.TopLeft ||
						this.Alignment == ContentAlignment.TopRight)
					{
						imagePosition.Y = this.cellPosition.Y;
					}

					// Set image transparent color
					System.Drawing.Imaging.ImageAttributes imageAttributes = new System.Drawing.Imaging.ImageAttributes();
					if(this.ImageTransparentColor != Color.Empty)
					{
						imageAttributes.SetColorKey(this.ImageTransparentColor, this.ImageTransparentColor, System.Drawing.Imaging.ColorAdjustType.Default);
					}

					// Increase quality of image scaling
					SmoothingMode oldSmoothingMode = chartGraph.SmoothingMode;
					CompositingQuality oldCompositingQuality = chartGraph.Graphics.CompositingQuality;
					InterpolationMode oldInterpolationMode = chartGraph.Graphics.InterpolationMode;
					chartGraph.SmoothingMode = SmoothingMode.AntiAlias;
					chartGraph.Graphics.CompositingQuality = CompositingQuality.HighQuality;
					chartGraph.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

					// Draw image
					chartGraph.DrawImage(
						image, 
						imagePosition, 
						0, 
						0, 
						image.Width,
						image.Height,
						GraphicsUnit.Pixel,
						imageAttributes);

					// Restore graphics settings
					chartGraph.SmoothingMode = oldSmoothingMode;
					chartGraph.Graphics.CompositingQuality = oldCompositingQuality;
					chartGraph.Graphics.InterpolationMode = oldInterpolationMode;
				}
			}

            /// <summary>
            /// Paint a series symbol in the cell.
            /// </summary>
            /// <param name="chartGraph">Chart graphics</param>
            /// <param name="singleWCharacterSize">Size of the 'W' character in auto-fit font.</param>
			private void PaintCellSeriesSymbol(
				ChartGraphics chartGraph, 
				SizeF singleWCharacterSize)
			{
                //Cache legend item
                LegendItem legendItem = this.LegendItem;

				// Calculate cell position
				Rectangle seriesMarkerPosition = this.cellPosition;

				// Adjust cell size using image symbol size specified
				if(this.SeriesSymbolSize.Width >= 0)
				{
					int newWidth = (int)(this.SeriesSymbolSize.Width * singleWCharacterSize.Width / 100f);
					if(newWidth > this.cellPosition.Width)
					{
						newWidth = this.cellPosition.Width;
					}
					seriesMarkerPosition.Width = newWidth;
				}
				if(this.SeriesSymbolSize.Height >= 0)
				{
					int newHeight = (int)(this.SeriesSymbolSize.Height * singleWCharacterSize.Height / 100f);
					if(newHeight > this.cellPosition.Height)
					{
						newHeight = this.cellPosition.Height;
					}
					seriesMarkerPosition.Height = newHeight;
				}

				// Check for empty size
				if(seriesMarkerPosition.Height <= 0 || seriesMarkerPosition.Width <= 0)
				{
					return;
				}

				// Get symbol location
				seriesMarkerPosition.X = (int)((this.cellPosition.X + this.cellPosition.Width/2f) - seriesMarkerPosition.Width/2f);
				seriesMarkerPosition.Y = (int)((this.cellPosition.Y + this.cellPosition.Height/2f) - seriesMarkerPosition.Height/2f);

				// Adjust image location based on the cell content alignment
				if(this.Alignment == ContentAlignment.BottomLeft || 
					this.Alignment == ContentAlignment.MiddleLeft ||
					this.Alignment == ContentAlignment.TopLeft)
				{
					seriesMarkerPosition.X = this.cellPosition.X;
				}
				else if(this.Alignment == ContentAlignment.BottomRight || 
					this.Alignment == ContentAlignment.MiddleRight ||
					this.Alignment == ContentAlignment.TopRight)
				{
					seriesMarkerPosition.X = this.cellPosition.Right - seriesMarkerPosition.Width;
				}
				
				if(this.Alignment == ContentAlignment.BottomCenter || 
					this.Alignment == ContentAlignment.BottomLeft ||
					this.Alignment == ContentAlignment.BottomRight)
				{
					seriesMarkerPosition.Y = this.cellPosition.Bottom - seriesMarkerPosition.Height;
				}
				else if(this.Alignment == ContentAlignment.TopCenter || 
					this.Alignment == ContentAlignment.TopLeft ||
					this.Alignment == ContentAlignment.TopRight)
				{
					seriesMarkerPosition.Y = this.cellPosition.Y;
				}

				// Start Svg Selection mode
				chartGraph.StartHotRegion( this.GetCellUrl(), this.GetCellToolTip() );

				// Draw legend item image
				if(legendItem.Image.Length > 0)
				{
					// Get image size
					Rectangle	imageScale = Rectangle.Empty;
                    System.Drawing.Image image = this.Common.ImageLoader.LoadImage(legendItem.Image);
                                       
                    if (image != null)
                    {
                        SizeF imageSize = new SizeF();

                        ImageLoader.GetAdjustedImageSize(image, chartGraph.Graphics, ref imageSize);

                        imageScale.Width = (int)imageSize.Width;
                        imageScale.Height = (int)imageSize.Height;

                        // Make sure image size fits into the drawing rectangle
                        float scaleValue = 1f;
                        if (imageScale.Height > seriesMarkerPosition.Height)
                        {
                            scaleValue = (float)imageScale.Height / (float)seriesMarkerPosition.Height;
                        }
                        if (imageScale.Width > seriesMarkerPosition.Width)
                        {
                            scaleValue = Math.Max(scaleValue, (float)imageScale.Width / (float)seriesMarkerPosition.Width);
                        }

                        // Scale image size
                        imageScale.Height = (int)(imageScale.Height / scaleValue);
                        imageScale.Width = (int)(imageScale.Width / scaleValue);

                        imageScale.X = (int)((seriesMarkerPosition.X + seriesMarkerPosition.Width / 2f) - imageScale.Width / 2f);
                        imageScale.Y = (int)((seriesMarkerPosition.Y + seriesMarkerPosition.Height / 2f) - imageScale.Height / 2f);

                        // Set image transparent color
                        System.Drawing.Imaging.ImageAttributes imageAttributes = new System.Drawing.Imaging.ImageAttributes();
                        if (legendItem.BackImageTransparentColor != Color.Empty)
                        {
                            imageAttributes.SetColorKey(legendItem.BackImageTransparentColor, legendItem.BackImageTransparentColor, System.Drawing.Imaging.ColorAdjustType.Default);
                        }

                        // Draw image
                        chartGraph.DrawImage(
                            image,
                            imageScale,
                            0,
                            0,
                            image.Width,
                            image.Height,
                            GraphicsUnit.Pixel,
                            imageAttributes);
                    }
				}

				else
				{
                    int maxShadowOffset = (int)Math.Round((3 * chartGraph.Graphics.DpiX) / 96);
                    int maxBorderWidth = (int)Math.Round((3 * chartGraph.Graphics.DpiX) / 96);

					if(legendItem.ImageStyle == LegendImageStyle.Rectangle)
					{
                        int maxBorderWidthRect = (int)Math.Round((2 * chartGraph.Graphics.DpiX) / 96);
                    
						// Draw series rectangle
						chartGraph.FillRectangleRel(
							chartGraph.GetRelativeRectangle(seriesMarkerPosition), 
							legendItem.Color, 
							legendItem.BackHatchStyle, 
							legendItem.Image, 
							legendItem.backImageWrapMode, 
							legendItem.BackImageTransparentColor,
							legendItem.backImageAlign, 
							legendItem.backGradientStyle, 
							legendItem.backSecondaryColor,
							legendItem.borderColor,
                            (legendItem.BorderWidth > maxBorderWidthRect) ? maxBorderWidthRect : legendItem.BorderWidth,
							legendItem.BorderDashStyle,
							legendItem.ShadowColor,
                            (legendItem.ShadowOffset > maxShadowOffset) ? maxShadowOffset : legendItem.ShadowOffset,
							PenAlignment.Inset);
					}
					if(legendItem.ImageStyle == LegendImageStyle.Line)
					{
						// Prepare line coordinates
						Point	point1 = new Point();
						point1.X = seriesMarkerPosition.X;
						point1.Y = (int)(seriesMarkerPosition.Y + seriesMarkerPosition.Height/2F);
						Point	point2 = new Point();
						point2.Y = point1.Y;
						point2.X = seriesMarkerPosition.Right;

						// Disable antialiasing
						SmoothingMode oldMode = chartGraph.SmoothingMode;
						chartGraph.SmoothingMode = SmoothingMode.None;
                        
						// Draw line
						chartGraph.DrawLineRel(
							legendItem.Color,
                            (legendItem.borderWidth > maxBorderWidth) ? maxBorderWidth : legendItem.borderWidth,
							legendItem.borderDashStyle, 
							chartGraph.GetRelativePoint(point1), 
							chartGraph.GetRelativePoint(point2),
							legendItem.shadowColor,
                            (legendItem.shadowOffset > maxShadowOffset) ? maxShadowOffset : legendItem.shadowOffset);

						// Restore antialiasing mode
						chartGraph.SmoothingMode = oldMode;
					}
				
					// Draw symbol (for line also)
					if(legendItem.ImageStyle == LegendImageStyle.Marker ||
						legendItem.ImageStyle == LegendImageStyle.Line)
					{
						MarkerStyle	markerStyle = legendItem.markerStyle;
						if(legendItem.style == LegendImageStyle.Marker)
						{
							markerStyle = (legendItem.markerStyle == MarkerStyle.None) ? 
								MarkerStyle.Circle : legendItem.markerStyle;
						}

						if(markerStyle != MarkerStyle.None || 
							legendItem.markerImage.Length > 0)
						{
							// Calculate marker size
							int	markerSize = (int)Math.Min(seriesMarkerPosition.Width, seriesMarkerPosition.Height);
							markerSize = (int)Math.Min(legendItem.markerSize, (legendItem.style == LegendImageStyle.Line) ? 2f*(markerSize/3f) : markerSize);

							// Reduce marker size to fit border
                            int markerBorderWidth = (legendItem.MarkerBorderWidth > maxBorderWidth) ? maxBorderWidth : legendItem.MarkerBorderWidth;
							if(markerBorderWidth > 0)
							{
								markerSize -= markerBorderWidth;
								if(markerSize < 1)
								{
									markerSize = 1;
								}
							}
							
							// Draw marker
							Point	point = new Point();
							point.X = (int)(seriesMarkerPosition.X + seriesMarkerPosition.Width/2f);
							point.Y = (int)(seriesMarkerPosition.Y + seriesMarkerPosition.Height/2f);

							// Calculate image scale
							Rectangle	imageScale = Rectangle.Empty;
							if(legendItem.markerImage.Length > 0)
							{
								// Get image size
                                System.Drawing.Image image = this.Common.ImageLoader.LoadImage(legendItem.markerImage);

                                SizeF imageSize = new SizeF();

                                ImageLoader.GetAdjustedImageSize(image, chartGraph.Graphics, ref imageSize);

                                imageScale.Width = (int)imageSize.Width;
                                imageScale.Height = (int)imageSize.Height;
                                
								// Make sure image size fits into the drawing rectangle
								float	scaleValue = 1f;
								if(imageScale.Height > seriesMarkerPosition.Height)
								{
									scaleValue = (float)imageScale.Height / (float)seriesMarkerPosition.Height;
								}
								if(imageScale.Width > seriesMarkerPosition.Width)
								{
									scaleValue = Math.Max(scaleValue, (float)imageScale.Width / (float)seriesMarkerPosition.Width);
								}

								// Scale image size
								imageScale.Height = (int)(imageScale.Height / scaleValue);
								imageScale.Width = (int)(imageScale.Width / scaleValue);
							}

							// Adjust marker position so that it always drawn on pixel
							// boundary.
							PointF pointF = new PointF(point.X, point.Y);
							if( (markerSize%2) != 0.0 )
							{
								pointF.X -= 0.5f;
								pointF.Y -= 0.5f;
							}

							// Draw marker if it's not image
							chartGraph.DrawMarkerRel(
								chartGraph.GetRelativePoint(pointF),
								markerStyle,
								markerSize,
								(legendItem.markerColor == Color.Empty) ? legendItem.Color : legendItem.markerColor,
								(legendItem.markerBorderColor == Color.Empty) ? legendItem.borderColor : legendItem.markerBorderColor,
								markerBorderWidth,
								legendItem.markerImage, 
								legendItem.markerImageTransparentColor,
								(legendItem.shadowOffset > maxShadowOffset) ? maxShadowOffset : legendItem.shadowOffset,
								legendItem.shadowColor,
								imageScale);
						}
					}
				}
				
				// End Svg Selection mode
				chartGraph.EndHotRegion( );
			}

			#endregion // Cell Painting Methods

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


            #endregion
        }

		/// <summary>
        /// The Margins class represents the margins for various chart elements. 
		/// </summary>
		[
		SRDescription("DescriptionAttributeMargins_Margins"),
		TypeConverter(typeof(MarginExpandableObjectConverter)),
		]
#if ASPPERM_35
	[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
        public class Margins
		{
			#region Fields
			
			// Top margin
			private		int _top = 0;

			// Bottom margin
			private		int _bottom = 0;

			// Left margin
			private		int _left = 0;

			// Right margin
			private		int _right = 0;

#if Microsoft_CONTROL

			// Reference to common chart elements which allows to invalidate
			// chart when one of the properties is changed.
			internal	CommonElements	Common = null;

#endif // Microsoft_CONTROL

			#endregion // Fields

			#region Constructor

			/// <summary>
            /// Margins constructor.
			/// </summary>
            public Margins()
			{
			}

			/// <summary>
            /// Margins constructor.
			/// </summary>
			/// <param name="top">Top margin.</param>
			/// <param name="bottom">Bottom margin.</param>
			/// <param name="left">Left margin.</param>
			/// <param name="right">Right margin.</param>
            public Margins(int top, int bottom, int left, int right)
			{
				this._top = top;
				this._bottom = bottom;
				this._left = left;
				this._right = right;
			}

			#endregion // Constructor

			#region Properties

			/// <summary>
			/// Gets or sets the top margin.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			DefaultValue(0),
			SRDescription("DescriptionAttributeMargins_Top"),
			RefreshPropertiesAttribute(RefreshProperties.All),
			NotifyParentPropertyAttribute(true),
			]
			public int Top
			{
                get
				{
					return this._top;
				}
                set
				{
					if(value < 0)
					{
                        throw (new ArgumentException(SR.ExceptionMarginTopIsNegative, "value"));
					}
					this._top = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the bottom margin.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			DefaultValue(0),
			SRDescription("DescriptionAttributeMargins_Bottom"),
			RefreshPropertiesAttribute(RefreshProperties.All),
			NotifyParentPropertyAttribute(true),
			]
			public int Bottom
			{
                get
				{
					return this._bottom;
				}
                set
				{
					if(value < 0)
					{
                        throw (new ArgumentException(SR.ExceptionMarginBottomIsNegative, "value"));
					}
					this._bottom = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the left margin.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			DefaultValue(0),
			RefreshPropertiesAttribute(RefreshProperties.All),
			SRDescription("DescriptionAttributeMargins_Left"),
			NotifyParentPropertyAttribute(true),
			]
			public int Left
			{
                get
				{
					return this._left;
				}
                set
				{
					if(value < 0)
					{
                        throw (new ArgumentException(SR.ExceptionMarginLeftIsNegative, "value"));
					}
					this._left = value;
					this.Invalidate();
				}
			}

			/// <summary>
            /// Gets or sets the right margin.
			/// </summary>
			[
			SRCategory("CategoryAttributeMisc"),
			DefaultValue(0),
			SRDescription("DescriptionAttributeMargins_Right"),
			RefreshPropertiesAttribute(RefreshProperties.All),
			NotifyParentPropertyAttribute(true),
			]
			public int Right
			{
                get
				{
					return this._right;
				}
                set
				{
					if(value < 0)
					{
                        throw (new ArgumentException(SR.ExceptionMarginRightIsNegative, "value"));
					}
					this._right = value;
					this.Invalidate();
				}
			}

			#endregion // Properties

			#region Methods

			/// <summary>
			/// Convert margins object to string.
			/// </summary>
			/// <returns>A string that represents the margins object.</returns>
            [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
            public override string ToString()
			{
				return string.Format(
                    CultureInfo.InvariantCulture,
					"{0:D}, {1:D}, {2:D}, {3:D}", 
					this.Top, 
					this.Bottom, 
					this.Left, 
					this.Right);
			}

			/// <summary>
			/// Determines whether the specified Object is equal to the current Object.
			/// </summary>
			/// <param name="obj">
			/// The Object to compare with the current Object.
			/// </param>
			/// <returns>
			/// True if the specified Object is equal to the current Object; otherwise, false.
			/// </returns>
            [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
            public override bool Equals(object obj)
			{
				Margins margins = obj as Margins;
				if(margins != null)
				{
					if(this.Top == margins.Top &&
						this.Bottom == margins.Bottom &&
						this.Left == margins.Left &&
						this.Right == margins.Right)
					{
						return true;
					}
				}
				return false;
			}

			/// <summary>
			/// Gets object hash code.
			/// </summary>
			/// <returns>Margins object hash value.</returns>
            [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
            public override int GetHashCode()
			{
				return this.Top.GetHashCode() + this.Bottom.GetHashCode() + this.Left.GetHashCode() + this.Right.GetHashCode();
			}

			/// <summary>
			/// Checks if there is no margin.
			/// </summary>
			/// <returns>
			/// <b>True</b> if all margins values are zeros.
			/// </returns>
            public bool IsEmpty()
			{
				return (this.Top == 0 && this.Bottom == 0 && this.Left == 0 && this.Right ==0);
			}

			/// <summary>
			/// Converts Margins class to RectangleF class.
			/// </summary>
			/// <returns>A RectangleF class that contains the values of the margins.</returns>
            public RectangleF ToRectangleF()
			{
				return new RectangleF(this.Left, this.Top, this.Right, this.Bottom);
			}

			/// <summary>
			/// Invalidates chart.
			/// </summary>
			private void Invalidate()
			{
#if Microsoft_CONTROL
				if(this.Common != null && this.Common.Chart != null)
				{
					this.Common.Chart.Invalidate();
				}
#endif // Microsoft_CONTROL
			}

			#endregion // Methods
		}

		/// <summary>
		/// <b>LegendCellCollection</b> is a strongly typed collection of LegendCell objects.
		/// </summary>
		[
		SRDescription("DescriptionAttributeLegendCellCollection_LegendCellCollection"),
		]
#if ASPPERM_35
	[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
        public class LegendCellCollection : ChartNamedElementCollection<LegendCell>
		{

			#region Constructors

			/// <summary>
            /// LegendCellCollection constructor.
			/// </summary>
			/// <remarks>
			/// This constructor is for internal use and should not be part of documentation.
			/// </remarks>
            /// <param name="parent">Legend item this collection belongs to.</param>
			internal LegendCellCollection(LegendItem parent) : base (parent)
			{
			}

			#endregion 

            #region Methods
            /// <summary>
			/// Adds a cell to the end of the collection.
			/// </summary>
			/// <param name="cellType">
			/// A <see cref="LegendCellType"/> value representing the cell type.
			/// </param>
			/// <param name="text">
			/// A <b>string</b> value representing cell text or image name depending 
			/// on the <b>cellType</b> parameter.
			/// </param>
			/// <param name="alignment">
			/// A <see cref="ContentAlignment"/> value representing cell content alignment.
			/// </param>
			/// <returns>
			/// Index of the newly added object.
			/// </returns>
			public int Add(LegendCellType cellType, string text, ContentAlignment alignment)
			{                
				Add(new LegendCell(cellType, text, alignment));
                return Count - 1;
			}

			/// <summary>
			/// Inserts a cell into the collection.
			/// </summary>
			/// <param name="index">
			/// Index to insert the object at.
			/// </param>
			/// <param name="cellType">
			/// A <see cref="LegendCellType"/> value representing the cell type.
			/// </param>
			/// <param name="text">
			/// A <b>string</b> value representing cell text or image name depending 
			/// on the <b>cellType</b> parameter.
			/// </param>
			/// <param name="alignment">
			/// A <see cref="ContentAlignment"/> value representing cell content alignment.
			/// </param>
			public void Insert(int index, LegendCellType cellType, string text, ContentAlignment alignment)
			{
				this.Insert(index, new LegendCell(cellType, text, alignment));
            }

            #endregion

        }

		/// <summary>
		/// The <b>LegendCellColumnCollection</b> class is a strongly typed collection
        /// of LegendCellColumn objects.
		/// </summary>
		[
		SRDescription("DescriptionAttributeLegendCellColumnCollection_LegendCellColumnCollection"),
		]
#if ASPPERM_35
	[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
        [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
        public class LegendCellColumnCollection : ChartNamedElementCollection<LegendCellColumn>
		{
    		
			#region Construction and Initialization

			/// <summary>
            /// LegendCellColumnCollection constructor.
			/// </summary>
			/// <remarks>
			/// This constructor is for internal use and should not be part of documentation.
			/// </remarks>
			/// <param name="legend">
			/// Chart legend which this collection belongs to.
			/// </param>
            internal LegendCellColumnCollection(Legend legend)
                : base(legend)
            {
            }

			#endregion // Construction and Initialization

            #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
                    foreach (LegendCellColumn item in this)
                    {
                        item.Dispose();
                    }
                    this.ClearItems();
                }
                base.Dispose(disposing);
            }


            #endregion
		}
    
}