2910 lines
86 KiB
C#
2910 lines
86 KiB
C#
//-------------------------------------------------------------
|
||
// <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
|
||
}
|
||
|
||
}
|
||
|