mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
linux-packaging-mono/mcs/class/referencesource/System.Web.DataVisualization/Common/DataManager/DataPoint.cs
Pat Tullmann 0cb742dafb binfmt-detector-cli: rewrite to support PE32+ binaries (#38) 
Rewrite with hard-coded offsets into the PE file format to discern
if a binary is PE32 or PE32+, and then to determine if it contains
a "CLR Data Directory" entry that looks valid.

Tested with PE32 and PE32+ compiled Mono binaries, PE32 and PE32+ native
binaries, and a random assortment of garbage files.

Former-commit-id: 9e7ac86ec84f653a2f79b87183efd5b0ebda001b
2023-10-16 20:16:47 +02:00

7045 lines
196 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
// Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
// File: DataPoint.cs
//
// Namespace: System.Web.UI.WebControls[Windows.Forms].Charting.Data
//
// Classes: DataPoint, DataPointCustomProperties, DataPointCollection,
// DataPointComparer, DataPoint3D, CustomProperties
//
// Purpose: Classes related to the Data Points:
// DataPointCollection - data points collection class
// DataPoint - data point properties and methods
// DataPointCustomProperties - data point & series properties
// DataPointComparer - used for sorting data points in series
//
// Reviewed: AG - Aug 1, 2002, GS - Aug 7, 2002
//
//===================================================================
#region Used namespaces
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Data.Common;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
#if Microsoft_CONTROL
using System.Windows.Forms.DataVisualization.Charting;
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.ComponentModel.Design.Serialization;
using System.Reflection;
using System.CodeDom;
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.Utilities;
using System.IO;
#endif
#endregion
#if Microsoft_CONTROL
namespace System.Windows.Forms.DataVisualization.Charting
#else
namespace System.Web.UI.DataVisualization.Charting
#endif
{
#region CustomProperties enumeration
/// <summary>
/// Enumeration of common properties names.
/// </summary>
internal enum CommonCustomProperties
{
PointName,
Label,
AxisLabel,
LabelFormat,
IsValueShownAsLabel,
Color,
BorderColor,
BorderDashStyle,
BorderWidth,
BackImage,
BackImageWrapMode,
BackImageAlignment,
BackImageTransparentColor,
BackGradientStyle,
BackSecondaryColor,
BackHatchStyle,
Font,
LabelForeColor,
LabelAngle,
MarkerStyle,
MarkerSize,
MarkerImage,
MarkerImageTransparentColor,
MarkerColor,
MarkerBorderColor,
MarkerBorderWidth,
MapAreaAttributes,
PostBackValue,
MapAreaType,
LegendMapAreaType,
LabelMapAreaType,
Url,
ToolTip,
Tag,
LegendUrl,
LegendToolTip,
LegendText,
LegendMapAreaAttributes,
LegendPostBackValue,
IsVisibleInLegend,
LabelUrl,
LabelToolTip,
LabelMapAreaAttributes,
LabelPostBackValue,
LabelBorderColor,
LabelBorderDashStyle,
LabelBorderWidth,
LabelBackColor,
};
#endregion
/// <summary>
/// Data points comparer class
/// </summary>
[
SRDescription("DescriptionAttributeDataPointComparer_DataPointComparer")
]
public class DataPointComparer : IComparer<DataPoint>
{
#region Fields
// Sorting order
private PointSortOrder _sortingOrder = PointSortOrder.Ascending;
// Sorting value index
private int _sortingValueIndex = 1;
#endregion
#region Constructors
/// <summary>
/// Private default constructor.
/// </summary>
private DataPointComparer()
{
}
/// <summary>
/// Data points comparer class constructor.
/// </summary>
/// <param name="series">Data series.</param>
/// <param name="sortOrder">Sorting order.</param>
/// <param name="sortBy">Value used for sorting ("X", "Y or Y1", "Y2", ...).</param>
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
public DataPointComparer(Series series, PointSortOrder sortOrder, string sortBy)
{
// Check if sorting value is valid
sortBy = sortBy.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
if(String.Compare(sortBy, "X", StringComparison.Ordinal) == 0)
{
_sortingValueIndex = -1;
}
else if (String.Compare(sortBy, "Y", StringComparison.Ordinal) == 0)
{
_sortingValueIndex = 0;
}
else if (String.Compare(sortBy, "AXISLABEL", StringComparison.Ordinal) == 0)
{
_sortingValueIndex = -2;
}
else if(sortBy.Length == 2 &&
sortBy.StartsWith("Y", StringComparison.Ordinal) &&
Char.IsDigit(sortBy[1]))
{
_sortingValueIndex = Int32.Parse(sortBy.Substring(1), System.Globalization.CultureInfo.InvariantCulture) - 1;
}
else
{
throw(new ArgumentException( SR.ExceptionDataPointConverterInvalidSorting, "sortBy"));
}
// Check if data series support as many Y values as required
if(_sortingValueIndex > 0 && _sortingValueIndex >= series.YValuesPerPoint)
{
throw(new ArgumentException( SR.ExceptionDataPointConverterUnavailableSorting(sortBy, series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture) ), "sortBy"));
}
this._sortingOrder = sortOrder;
}
#endregion
#region Comparing method
/// <summary>
/// Compares two data points.
/// </summary>
/// <param name="x">First data point.</param>
/// <param name="y">Second data point.</param>
/// <returns>If the two values are equal, it returns zero. If point 1 is greater than point 2,
/// it returns a positive integer; otherwise, it returns a negative integer.
/// </returns>
public int Compare(DataPoint x, DataPoint y)
{
int result = -1;
// Compare X value
if(_sortingValueIndex == -1)
{
result = x.XValue.CompareTo(y.XValue);
}
// Compare Axis Label value
else if(_sortingValueIndex == -2)
{
result = string.Compare(x.AxisLabel, y.AxisLabel, StringComparison.CurrentCulture);
}
// Compare one of the Y value(s)
else
{
result = x.YValues[_sortingValueIndex].CompareTo(y.YValues[_sortingValueIndex]);
}
// Invert result depending on the sorting order
if(this._sortingOrder == PointSortOrder.Descending)
{
result = -result;
}
return result;
}
#endregion
}
/// <summary>
/// A collection of data points.
/// </summary>
[
SRDescription("DescriptionAttributeDataPointCollection_DataPointCollection"),
]
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
#if !Microsoft_CONTROL
[Themeable(false)]
#endif
public class DataPointCollection : ChartElementCollection<DataPoint>
{
#region Fields
// Reference to the sereies of data points
internal Series series = null;
#endregion
#region Constructors and Initialization
/// <summary>
/// Data Point Collection object constructor.
/// </summary>
/// <param name="series">Series object, which the Data Point Collection belongs to.</param>
internal DataPointCollection(Series series) : base(series)
{
this.series = series;
}
/// <summary>
/// Initialize data point series and name.
/// </summary>
/// <param name="dataPoint">Reference to the data point object to initialize.</param>
internal void DataPointInit(ref DataPoint dataPoint)
{
DataPointInit(this.series, ref dataPoint);
}
/// <summary>
/// Initialize data point series and name.
/// </summary>
/// <param name="series">Series the data point belongs to.</param>
/// <param name="dataPoint">Reference to the data point object to initialize.</param>
internal static void DataPointInit(Series series, ref DataPoint dataPoint)
{
dataPoint.series = series;
if(dataPoint.AxisLabel.Length > 0 && series != null)
{
series.noLabelsInPoints = false;
}
#if Microsoft_CONTROL
// Set flag that tooltips flags should be recalculated
if(dataPoint.ToolTip.Length > 0 &&
dataPoint.LegendToolTip.Length > 0 &&
dataPoint.LabelToolTip.Length > 0 &&
series != null && series.Chart != null && series.Chart.selection != null)
{
series.Chart.selection.enabledChecked = false;
}
#endif
}
#endregion
#region Data point binding, adding and inserting methods
/// <summary>
/// Adds the new DataPoint to a collection and sets its Y values.
/// </summary>
/// <param name="y">The y.</param>
/// <returns></returns>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public DataPoint Add(params double[] y)
{
DataPoint point = new DataPoint(0, y);
this.Add(point);
return point;
}
/// <summary>
/// Parse the input parameter with other point attribute binding rule
/// in format: PointProperty=Field[{Format}] [,PointProperty=Field[{Format}]].
/// For example: "Tooltip=Price{C1},Url=WebSiteName".
/// </summary>
/// <param name="otherFields">Other fields parameter.</param>
/// <param name="otherAttributeNames">Returns array of attribute names.</param>
/// <param name="otherFieldNames">Returns array of field names.</param>
/// <param name="otherValueFormat">Returns array of format strings.</param>
internal static void ParsePointFieldsParameter(
string otherFields,
ref string[] otherAttributeNames,
ref string[] otherFieldNames,
ref string[] otherValueFormat)
{
if(otherFields != null && otherFields.Length > 0)
{
// Split string by comma
otherAttributeNames = otherFields.Replace(",,", "\n").Split(',');
otherFieldNames = new string[otherAttributeNames.Length];
otherValueFormat = new string[otherAttributeNames.Length];
// Loop through all strings
for(int index = 0; index < otherAttributeNames.Length; index++)
{
// Split string by equal sign
int equalSignIndex = otherAttributeNames[index].IndexOf('=');
if(equalSignIndex > 0)
{
otherFieldNames[index] = otherAttributeNames[index].Substring(equalSignIndex + 1);
otherAttributeNames[index] = otherAttributeNames[index].Substring(0, equalSignIndex);
}
else
{
throw (new ArgumentException(SR.ExceptionParameterFormatInvalid, "otherFields"));
}
// Check if format string was specified
int bracketIndex = otherFieldNames[index].IndexOf('{');
if(bracketIndex > 0 && otherFieldNames[index][otherFieldNames[index].Length - 1] == '}')
{
otherValueFormat[index] = otherFieldNames[index].Substring(bracketIndex + 1);
otherValueFormat[index] = otherValueFormat[index].Trim('{', '}');
otherFieldNames[index] = otherFieldNames[index].Substring(0, bracketIndex);
}
// Trim and replace new line character
otherAttributeNames[index] = otherAttributeNames[index].Trim().Replace("\n", ",");
otherFieldNames[index] = otherFieldNames[index].Trim().Replace("\n", ",");
if ( otherValueFormat[index] != null )
otherValueFormat[index] = otherValueFormat[index].Trim().Replace("\n", ",");
}
}
}
/// <summary>
/// Data bind X, Y and other values (like Tooltip, LabelStyle,...) of the data points to the data source.
/// Data source can be the Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="dataSource">Data source.</param>
/// <param name="xField">Name of the field for X values.</param>
/// <param name="yFields">Comma separated names of the fields for Y values.</param>
/// <param name="otherFields">Other point properties binding rule in format: PointProperty=Field[{Format}] [,PointProperty=Field[{Format}]]. For example: "Tooltip=Price{C1},Url=WebSiteName".</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void DataBind(IEnumerable dataSource, string xField, string yFields, string otherFields)
{
// Check arguments
if (dataSource == null)
throw new ArgumentNullException("dataSource", SR.ExceptionDataPointInsertionNoDataSource);
if (dataSource is string)
throw (new ArgumentException(SR.ExceptionDataBindSeriesToString, "dataSource"));
if (yFields == null)
throw new ArgumentNullException("yFields");
// Convert comma separated Y values field names string to array of names
string[] yFieldNames = yFields.Replace(",,", "\n").Split(',');
for(int index = 0; index < yFieldNames.Length; index++)
{
yFieldNames[index] = yFieldNames[index].Replace("\n", ",");
}
if (yFieldNames.GetLength(0) > series.YValuesPerPoint)
throw (new ArgumentOutOfRangeException("yFields", SR.ExceptionDataPointYValuesCountMismatch(series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture))));
// Convert other fields/properties names to two arrays of names
string[] otherAttributeNames = null;
string[] otherFieldNames = null;
string[] otherValueFormat = null;
ParsePointFieldsParameter(
otherFields,
ref otherAttributeNames,
ref otherFieldNames,
ref otherValueFormat);
// Remove all existing data points
this.Clear();
// Get and reset enumerator
IEnumerator enumerator = GetDataSourceEnumerator(dataSource);
if (enumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
{
try
{
enumerator.Reset();
}
// Some enumerators may not support Resetting
catch (InvalidOperationException)
{
}
catch (NotImplementedException)
{
}
catch (NotSupportedException)
{
}
}
// Add data points
bool valueExsist = true;
object[] yValuesObj = new object[yFieldNames.Length];
object xValueObj = null;
bool autoDetectType = true;
this.SuspendUpdates();
try
{
do
{
// Move to the next objects in the enumerations
if (valueExsist)
{
valueExsist = enumerator.MoveNext();
}
// Auto detect valu(s) type
if (autoDetectType)
{
autoDetectType = false;
AutoDetectValuesType(this.series, enumerator, xField, enumerator, yFieldNames[0]);
}
// Create and initialize data point
if (valueExsist)
{
DataPoint newDataPoint = new DataPoint(series);
bool emptyValues = false;
// Set X to the value provided
if (xField.Length > 0)
{
xValueObj = ConvertEnumerationItem(enumerator.Current, xField);
if (IsEmptyValue(xValueObj))
{
emptyValues = true;
xValueObj = 0.0;
}
}
// Set Y values
if (yFieldNames.Length == 0)
{
yValuesObj[0] = ConvertEnumerationItem(enumerator.Current, null);
if (IsEmptyValue(yValuesObj[0]))
{
emptyValues = true;
yValuesObj[0] = 0.0;
}
}
else
{
for (int i = 0; i < yFieldNames.Length; i++)
{
yValuesObj[i] = ConvertEnumerationItem(enumerator.Current, yFieldNames[i]);
if (IsEmptyValue(yValuesObj[i]))
{
emptyValues = true;
yValuesObj[i] = 0.0;
}
}
}
// Set other values
if (otherAttributeNames != null &&
otherAttributeNames.Length > 0)
{
for (int i = 0; i < otherFieldNames.Length; i++)
{
// Get object by field name
object obj = ConvertEnumerationItem(enumerator.Current, otherFieldNames[i]);
if (!IsEmptyValue(obj))
{
newDataPoint.SetPointCustomProperty(
obj,
otherAttributeNames[i],
otherValueFormat[i]);
}
}
}
// IsEmpty value was detected
if (emptyValues)
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
newDataPoint.IsEmpty = true;
this.Add(newDataPoint);
}
else
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
this.Add(newDataPoint);
}
}
} while (valueExsist);
}
finally
{
this.ResumeUpdates();
}
}
/// <summary>
/// Data bind Y values of the data points to the data source.
/// Data source can be the Array, Collection, Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="yValue">One or more enumerable objects with Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "Y is a cartesian coordinate and well understood")]
public void DataBindY(params IEnumerable[] yValue)
{
DataBindXY(null, yValue);
}
/// <summary>
/// Data bind X and Y values of the data points to the data source.
/// Data source can be the Array, Collection, Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="xValue">Enumerable objects with X values.</param>
/// <param name="yValues">One or more enumerable objects with Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void DataBindXY(IEnumerable xValue, params IEnumerable[] yValues)
{
// Y value must be provided
if (yValues == null ||
yValues.Length==1 && yValues[0]==null)
throw new ArgumentNullException("yValues");
if (yValues.GetLength(0) == 0)
throw new ArgumentException(SR.ExceptionDataPointBindingYValueNotSpecified, "yValues");
// Double check that a string object is not provided for data binding
for(int i = 0; i < yValues.Length; i++)
{
if(yValues[i] is string)
{
throw (new ArgumentException(SR.ExceptionDataBindYValuesToString, "yValues"));
}
}
// Check if number of Y values do not out of range
if(yValues.GetLength(0) > series.YValuesPerPoint)
{
throw(new ArgumentOutOfRangeException("yValues", SR.ExceptionDataPointYValuesBindingCountMismatch( series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture) ) ) );
}
// Remove all existing data points
this.Clear();
// Reset X, Y enumerators
IEnumerator xEnumerator = null;
IEnumerator[] yEnumerator = new IEnumerator[yValues.GetLength(0)];
if(xValue != null)
{
// Double check that a string object is not provided for data binding
if(xValue is string)
{
throw (new ArgumentException(SR.ExceptionDataBindXValuesToString, "xValue"));
}
// Get and reset Y values enumerators
xEnumerator = GetDataSourceEnumerator(xValue);
if(xEnumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
{
xEnumerator.Reset();
}
}
for(int i = 0; i < yValues.Length; i++)
{
// Get and reset Y values enumerators
yEnumerator[i] = GetDataSourceEnumerator(yValues[i]);
if(yEnumerator[i].GetType() != typeof(System.Data.Common.DbEnumerator))
{
yEnumerator[i].Reset();
}
}
// Add data points
bool xValueExsist = false;
bool yValueExsist = true;
object[] yValuesObj = new object[series.YValuesPerPoint];
object xValueObj = null;
bool autoDetectType = true;
SuspendUpdates();
try
{
do
{
// Move to the next objects in the enumerations
yValueExsist = true;
for (int i = 0; i < yValues.Length; i++)
{
if (yValueExsist)
{
yValueExsist = yEnumerator[i].MoveNext();
}
}
if (xValue != null)
{
xValueExsist = xEnumerator.MoveNext();
if (yValueExsist && !xValueExsist)
{
throw (new ArgumentOutOfRangeException("xValue", SR.ExceptionDataPointInsertionXValuesQtyIsLessYValues));
}
}
// Auto detect value(s) type
if (autoDetectType)
{
autoDetectType = false;
AutoDetectValuesType(this.series, xEnumerator, null, yEnumerator[0], null);
}
// Create and initialize data point
if (xValueExsist || yValueExsist)
{
DataPoint newDataPoint = new DataPoint(series);
bool emptyValues = false;
// Set X to the value provided
if (xValueExsist)
{
xValueObj = ConvertEnumerationItem(xEnumerator.Current, null);
if (xValueObj is System.DBNull || xValueObj == null)
{
emptyValues = true;
xValueObj = 0.0;
}
}
// Set Y values
for (int i = 0; i < yValues.Length; i++)
{
yValuesObj[i] = ConvertEnumerationItem(yEnumerator[i].Current, null);
if (yValuesObj[i] is System.DBNull || yValuesObj[i] == null)
{
emptyValues = true;
yValuesObj[i] = 0.0;
}
}
// IsEmpty value was detected
if (emptyValues)
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
newDataPoint.IsEmpty = true;
this.Add(newDataPoint);
}
else
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
this.Add(newDataPoint);
}
}
} while (xValueExsist || yValueExsist);
}
finally
{
this.ResumeUpdates();
}
}
/// <summary>
/// Data bind Y values of the data points to the data source.
/// Data source can be the Array, Collection, Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="yValue">Enumerable objects with Y values.</param>
/// <param name="yFields">Name of the fields for Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void DataBindY(IEnumerable yValue, string yFields)
{
DataBindXY(null, null, yValue, yFields);
}
/// <summary>
/// Data bind X and Y values of the data points to the data source.
/// Data source can be the Array, Collection, Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="xValue">Enumerable object with X values.</param>
/// <param name="xField">Name of the field for X values.</param>
/// <param name="yValue">Enumerable objects with Y values.</param>
/// <param name="yFields">Comma separated names of the fields for Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void DataBindXY(IEnumerable xValue, string xField, IEnumerable yValue, string yFields)
{
// Check arguments
if (xValue is string)
throw new ArgumentException(SR.ExceptionDataBindXValuesToString, "xValue");
if (yValue == null)
throw new ArgumentNullException("yValue", SR.ExceptionDataPointInsertionYValueNotSpecified);
if (yValue is string)
throw new ArgumentException(SR.ExceptionDataBindYValuesToString, "yValue");
if (yFields == null)
throw new ArgumentOutOfRangeException("yFields", SR.ExceptionDataPointYValuesCountMismatch(series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture)));
// Convert comma separated field names string to array of names
string[] yFieldNames = yFields.Replace(",,", "\n").Split(',');;
for(int index = 0; index < yFieldNames.Length; index++)
{
yFieldNames[index] = yFieldNames[index].Replace("\n", ",");
}
if (yFieldNames.GetLength(0) > series.YValuesPerPoint)
throw new ArgumentOutOfRangeException("yFields", SR.ExceptionDataPointYValuesCountMismatch(series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture)));
// Remove all existing data points
this.Clear();
// Reset X, Y enumerators
IEnumerator xEnumerator = null;
IEnumerator yEnumerator = GetDataSourceEnumerator(yValue);
if(yEnumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
{
yEnumerator.Reset();
}
if(xValue != null)
{
if(xValue != yValue)
{
xEnumerator = GetDataSourceEnumerator(xValue);
if(xEnumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
{
xEnumerator.Reset();
}
}
else
{
xEnumerator = yEnumerator;
}
}
// Add data points
bool xValueExsist = false;
bool yValueExsist = true;
object[] yValuesObj = new object[yFieldNames.Length];
object xValueObj = null;
bool autoDetectType = true;
this.SuspendUpdates();
try
{
do
{
// Move to the next objects in the enumerations
if (yValueExsist)
{
yValueExsist = yEnumerator.MoveNext();
}
if (xValue != null)
{
if (xValue != yValue)
{
xValueExsist = xEnumerator.MoveNext();
if (yValueExsist && !xValueExsist)
{
throw (new ArgumentOutOfRangeException("xValue", SR.ExceptionDataPointInsertionXValuesQtyIsLessYValues));
}
}
else
{
xValueExsist = yValueExsist;
}
}
// Auto detect valu(s) type
if (autoDetectType)
{
autoDetectType = false;
AutoDetectValuesType(this.series, xEnumerator, xField, yEnumerator, yFieldNames[0]);
}
// Create and initialize data point
if (xValueExsist || yValueExsist)
{
DataPoint newDataPoint = new DataPoint(series);
bool emptyValues = false;
// Set X to the value provided or use sequence numbers starting with 1
if (xValueExsist)
{
xValueObj = ConvertEnumerationItem(xEnumerator.Current, xField);
if (IsEmptyValue(xValueObj))
{
emptyValues = true;
xValueObj = 0.0;
}
}
if (yFieldNames.Length == 0)
{
yValuesObj[0] = ConvertEnumerationItem(yEnumerator.Current, null);
if (IsEmptyValue(yValuesObj[0]))
{
emptyValues = true;
yValuesObj[0] = 0.0;
}
}
else
{
for (int i = 0; i < yFieldNames.Length; i++)
{
yValuesObj[i] = ConvertEnumerationItem(yEnumerator.Current, yFieldNames[i]);
if (IsEmptyValue(yValuesObj[i]))
{
emptyValues = true;
yValuesObj[i] = 0.0;
}
}
}
// IsEmpty value was detected
if (emptyValues)
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
newDataPoint.IsEmpty = true;
this.Add(newDataPoint);
}
else
{
if (xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointInit(ref newDataPoint);
this.Add(newDataPoint);
}
}
} while (xValueExsist || yValueExsist);
}
finally
{
this.ResumeUpdates();
}
}
/// <summary>
/// Returns true if objet represents an empty value.
/// </summary>
/// <param name="val">Value to test.</param>
/// <returns>True if empty.</returns>
internal static bool IsEmptyValue(object val)
{
if(val is System.DBNull || val == null)
{
return true;
}
if(val is double && double.IsNaN((double)val))
{
return true;
}
if(val is Single && Single.IsNaN((Single)val))
{
return true;
}
return false;
}
/// <summary>
/// Adds one data point with one Y value.
/// </summary>
/// <param name="yValue">Y value of the data point.</param>
/// <returns>Index of newly added data point.</returns>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "Y is a cartesian coordinate and well understood")]
public int AddY(double yValue)
{
// Create new point object
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueY(yValue);
DataPointInit(ref newDataPoint);
Add(newDataPoint);
return Count - 1;
}
/// <summary>
/// Adds one data point with one or more Y values.
/// </summary>
/// <param name="yValue">List of Y values of the data point.</param>
/// <returns>Index of newly added data point.</returns>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "Y is a cartesian coordinate and well understood")]
public int AddY(params object[] yValue)
{
//Check arguments
if (yValue == null ||
yValue.Length==1 && yValue[0]==null)
throw new ArgumentNullException("yValue");
// Auto detect DateTime values type
if(this.series.YValueType == ChartValueType.Auto &&
yValue.Length > 0 &&
yValue[0] != null)
{
if (yValue[0] is DateTime)
{
this.series.YValueType = ChartValueType.DateTime;
this.series.autoYValueType = true;
}
else if (yValue[0] is DateTimeOffset)
{
this.series.YValueType = ChartValueType.DateTimeOffset;
this.series.autoYValueType = true;
}
}
// Create new point object
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueY(yValue);
DataPointInit(ref newDataPoint);
Add(newDataPoint);
return Count - 1;
}
/// <summary>
/// Adds one data point with X value and one Y value.
/// </summary>
/// <param name="yValue">Y value of the data point.</param>
/// <param name="xValue">X value of the data point.</param>
/// <returns>Index of newly added data poit.</returns>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public int AddXY(double xValue, double yValue)
{
// Create new point object
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueXY(xValue, yValue);
DataPointInit(ref newDataPoint);
Add(newDataPoint);
return Count - 1;
}
/// <summary>
/// Adds one data point with X value and one or more Y values.
/// </summary>
/// <param name="yValue">List of Y values of the data point.</param>
/// <param name="xValue">X value of the data point.</param>
/// <returns>Index of newly added data poit.</returns>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public int AddXY(object xValue, params object[] yValue)
{
// Auto detect DateTime and String values type
if(this.series.XValueType == ChartValueType.Auto)
{
if(xValue is DateTime)
{
this.series.XValueType = ChartValueType.DateTime;
}
if(xValue is DateTimeOffset)
{
this.series.XValueType = ChartValueType.DateTimeOffset;
}
if(xValue is string)
{
this.series.XValueType = ChartValueType.String;
}
this.series.autoXValueType = true;
}
if(this.series.YValueType == ChartValueType.Auto &&
yValue.Length > 0 &&
yValue[0] != null)
{
if (yValue[0] is DateTime)
{
this.series.YValueType = ChartValueType.DateTime;
this.series.autoYValueType = true;
}
else if (yValue[0] is DateTimeOffset)
{
this.series.YValueType = ChartValueType.DateTimeOffset;
this.series.autoYValueType = true;
}
}
// Create new point object
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueXY(xValue, yValue);
DataPointInit(ref newDataPoint);
Add(newDataPoint);
return Count - 1;
}
/// <summary>
/// Insert one data point with X value and one or more Y values.
/// </summary>
/// <param name="index">Index after which to insert the data point.</param>
/// <param name="xValue">X value of the data point.</param>
/// <param name="yValue">List of Y values of the data point.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void InsertXY(int index, object xValue, params object[] yValue)
{
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueXY(xValue, yValue);
DataPointInit(ref newDataPoint);
this.Insert(index, newDataPoint);
}
/// <summary>
/// Insert one data point with one or more Y values.
/// </summary>
/// <param name="index">Index after which to insert the data point.</param>
/// <param name="yValue">List of Y values of the data point.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "Y is a cartesian coordinate and well understood")]
public void InsertY(int index, params object[] yValue)
{
DataPoint newDataPoint = new DataPoint(series);
newDataPoint.SetValueY(yValue);
DataPointInit(ref newDataPoint);
this.Insert(index, newDataPoint);
}
/// <summary>
/// Get data source enumerator object helper function.
/// </summary>
/// <param name="dataSource">Data source.</param>
/// <returns>Returns data source enumerator.</returns>
internal static IEnumerator GetDataSourceEnumerator(IEnumerable dataSource)
{
DataView dataView = dataSource as DataView;
if(dataView != null)
{
return dataView.GetEnumerator();
}
DataSet dataSet = dataSource as DataSet;
if(dataSet != null)
{
if(dataSet.Tables.Count > 0)
{
return dataSet.Tables[0].Rows.GetEnumerator();
}
}
return dataSource.GetEnumerator();
}
/// <summary>
/// Convert enumeration item object from DataRow and DataRowView
/// to the actual value of specified column in row
/// </summary>
/// <param name="item">Enumeration item.</param>
/// <param name="fieldName">Converted item.</param>
/// <returns></returns>
internal static object ConvertEnumerationItem(object item, string fieldName)
{
object result = item;
// If original object is DataRow
DataRow dataRow = item as DataRow;
if(dataRow != null)
{
if(fieldName != null && fieldName.Length > 0)
{
// Check if specified column exist
bool failed = true;
if (dataRow.Table.Columns.Contains(fieldName))
{
result = dataRow[fieldName];
failed = false;
}
else
{
// Try to treat field name as column index number
int columnIndex;
failed = !int.TryParse(fieldName, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (!failed && columnIndex < dataRow.Table.Columns.Count && columnIndex >= 0)
{
result = dataRow[columnIndex];
}
}
if(failed)
{
throw(new ArgumentException( SR.ExceptionColumnNameNotFound( fieldName) ) );
}
}
else
{
// Get first column value if name not specified
result = dataRow[0];
}
}
// If original object is DataRowView
DataRowView dataRowView = item as DataRowView;
if(dataRowView != null)
{
if(fieldName != null && fieldName.Length > 0)
{
// Check if specified column exist
bool failed = true;
if (dataRowView.DataView.Table.Columns.Contains(fieldName))
{
result = dataRowView[fieldName];
failed = false;
}
else
{
// Try to treat field name as column index number
int columnIndex;
failed = !int.TryParse(fieldName, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (!failed && columnIndex < dataRowView.DataView.Table.Columns.Count && columnIndex >= 0)
{
result = dataRowView[columnIndex];
}
}
if(failed)
{
throw(new ArgumentException( SR.ExceptionColumnNameNotFound(fieldName)));
}
}
else
{
// Get first column value if name not specified
result = dataRowView[0];
}
}
// If original object is DbDataRecord
DbDataRecord dbDataRecord = item as DbDataRecord;
if(dbDataRecord != null)
{
if(fieldName != null && fieldName.Length > 0)
{
// Check if specified column exist
bool failed = true;
if(!Char.IsNumber(fieldName, 0))
{
try
{
result = dbDataRecord[fieldName];
failed = false;
}
catch (IndexOutOfRangeException)
{
failed = true;
}
}
if(failed)
{
// Try to treat field name as column index number
try
{
int columnIndex;
bool parseSucceed = int.TryParse(fieldName, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (parseSucceed)
{
result = dbDataRecord[columnIndex];
failed = false;
}
else
{
failed = true;
}
}
catch (IndexOutOfRangeException)
{
failed = true;
}
}
if(failed)
{
throw(new ArgumentException( SR.ExceptionColumnNameNotFound(fieldName)));
}
}
else
{
// Get first column value if name not specified
result = dbDataRecord[0];
}
}
else
{
if (fieldName != null && fieldName.Length > 0)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(item).Find(fieldName, true);
if (descriptor != null)
{
result = descriptor.GetValue(item);
return result ?? null;
}
}
}
return result;
}
/// <summary>
/// Auto detects the X and Y(s) values type
/// </summary>
/// <param name="series">Series the values type is detected for.</param>
/// <param name="xEnumerator">X values enumerator.</param>
/// <param name="xField">X value field.</param>
/// <param name="yEnumerator">Y values enumerator.</param>
/// <param name="yField">Y value field.</param>
internal static void AutoDetectValuesType(
Series series,
IEnumerator xEnumerator,
string xField,
IEnumerator yEnumerator,
string yField)
{
if(series.XValueType == ChartValueType.Auto)
{
series.XValueType = GetValueType(xEnumerator, xField);
if(series.XValueType != ChartValueType.Auto)
{
series.autoXValueType = true;
}
}
if(series.YValueType == ChartValueType.Auto)
{
series.YValueType = GetValueType(yEnumerator, yField);
if(series.YValueType != ChartValueType.Auto)
{
series.autoYValueType = true;
}
}
}
/// <summary>
/// Return value type.
/// </summary>
/// <param name="enumerator">Values enumerator.</param>
/// <param name="field">Value field.</param>
private static ChartValueType GetValueType(IEnumerator enumerator, string field)
{
ChartValueType type = ChartValueType.Auto;
Type columnDataType = null;
// Check parameters
if(enumerator == null)
{
return type;
}
// Check if current enumeration element is available
try
{
if(enumerator.Current == null)
{
return type;
}
}
catch(InvalidOperationException)
{
return type;
}
// If original object is DataRow
if(enumerator.Current is DataRow)
{
if(field != null && field.Length > 0)
{
// Check if specified column exist
bool failed = true;
if(((DataRow)enumerator.Current).Table.Columns.Contains(field))
{
columnDataType = ((DataRow)enumerator.Current).Table.Columns[field].DataType;
failed = false;
}
// Try to treat field as column number
if (failed)
{
int columnIndex;
bool parseSucceed = int.TryParse(field, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (parseSucceed)
{
columnDataType = ((DataRow)enumerator.Current).Table.Columns[columnIndex].DataType;
failed = false;
}
else
{
failed = true;
}
}
if(failed)
{
throw(new ArgumentException( SR.ExceptionColumnNameNotFound(field)));
}
}
else if(((DataRow)enumerator.Current).Table.Columns.Count > 0)
{
columnDataType = ((DataRow)enumerator.Current).Table.Columns[0].DataType;
}
}
// If original object is DataRowView
else if(enumerator.Current is DataRowView)
{
if(field != null && field.Length > 0)
{
// Check if specified column exist
bool failed = true;
if(((DataRowView)enumerator.Current).DataView.Table.Columns.Contains(field))
{
columnDataType = ((DataRowView)enumerator.Current).DataView.Table.Columns[field].DataType;
failed = false;
}
// Try to treat field as column number
if (failed)
{
int columnIndex;
bool parseSucceed = int.TryParse(field, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (parseSucceed)
{
columnDataType = ((DataRowView)enumerator.Current).DataView.Table.Columns[columnIndex].DataType;
failed = false;
}
else
{
failed = true;
}
}
if(failed)
{
throw(new ArgumentException(SR.ExceptionColumnNameNotFound(field)));
}
}
else if(((DataRowView)enumerator.Current).DataView.Table.Columns.Count > 0)
{
columnDataType = ((DataRowView)enumerator.Current).DataView.Table.Columns[0].DataType;
}
}
// If original object is DbDataRecord
else if(enumerator.Current is DbDataRecord)
{
if(field != null && field.Length > 0)
{
bool failed = true;
int columnIndex = 0;
if(!Char.IsNumber(field, 0))
{
columnIndex = ((DbDataRecord)enumerator.Current).GetOrdinal(field);
columnDataType = ((DbDataRecord)enumerator.Current).GetFieldType(columnIndex);
failed = false;
}
// Try to treat field as column number
if (failed)
{
failed = !int.TryParse(field, NumberStyles.Any, CultureInfo.InvariantCulture, out columnIndex);
if (!failed)
{
columnDataType = ((DbDataRecord)enumerator.Current).GetFieldType(columnIndex);
}
}
if(failed)
{
throw(new ArgumentException(SR.ExceptionColumnNameNotFound(field)));
}
}
else if(((DbDataRecord)enumerator.Current).FieldCount > 0)
{
columnDataType = ((DbDataRecord)enumerator.Current).GetFieldType(0);
}
}
// Try detecting simple data types
else
{
if (field != null && field.Length > 0)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(enumerator.Current).Find(field, true);
if (descriptor != null)
{
columnDataType = descriptor.PropertyType;
}
}
if ( columnDataType == null )
{
columnDataType = enumerator.Current.GetType();
}
}
// Use data type
if(columnDataType != null)
{
if(columnDataType == typeof(DateTime))
type = ChartValueType.DateTime;
else if (columnDataType == typeof(DateTimeOffset))
type = ChartValueType.DateTimeOffset;
else if (columnDataType == typeof(TimeSpan))
type = ChartValueType.Time;
else if (columnDataType == typeof(Double))
type = ChartValueType.Double;
else if (columnDataType == typeof(Int32))
type = ChartValueType.Int32;
else if(columnDataType == typeof(Int64))
type = ChartValueType.Int64;
else if(columnDataType == typeof(Single))
type = ChartValueType.Single;
else if(columnDataType == typeof(String))
type = ChartValueType.String;
else if(columnDataType == typeof(UInt32))
type = ChartValueType.UInt32;
else if(columnDataType == typeof(UInt64))
type = ChartValueType.UInt64;
}
return type;
}
#endregion
#region DataPoint finding functions
/// <summary>
/// Find all the points that equal to the specified value starting from the specified index.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <param name="startIndex">Index of the point to start looking from.</param>
/// <returns>Enumerator of datapoints.</returns>
public IEnumerable<DataPoint> FindAllByValue(double valueToFind, string useValue, int startIndex)
{
// Loop through all points from specified index
for (int i = startIndex; i < this.Count; i++)
{
DataPoint point = this[i];
if (point.GetValueByName(useValue) == valueToFind)
{
yield return point;
}
}
}
/// <summary>
/// Find all the points that equal to the specified value.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <returns>Enumerator of datapoints.</returns>
public IEnumerable<DataPoint> FindAllByValue(double valueToFind, string useValue)
{
// Loop through all points from specified index
for (int i = 0; i < this.Count; i++)
{
DataPoint point = this[i];
if (point.GetValueByName(useValue) == valueToFind)
{
yield return point;
}
}
}
/// <summary>
/// Find all the points that equal to the specified value.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <returns>Enumerator of datapoints.</returns>
public IEnumerable<DataPoint> FindAllByValue(double valueToFind)
{
return FindAllByValue(valueToFind, "Y");
}
/// <summary>
/// Find the first point that equals to the specified value starting from the specified index.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <param name="startIndex">Index of the point to start looking from.</param>
/// <returns>Datapoint which matches the value. Null if there is no match.</returns>
public DataPoint FindByValue(double valueToFind, string useValue, int startIndex)
{
//Check arguments
if (useValue == null)
throw new ArgumentNullException("useValue");
if (startIndex < 0 || startIndex >= this.Count)
throw new ArgumentOutOfRangeException("startIndex");
// Loop through all points from specified index
for (int i = startIndex; i < this.Count; i++)
{
DataPoint point = this[i];
if (point.GetValueByName(useValue) == valueToFind)
{
return point;
}
}
// Nothing was found
return null;
}
/// <summary>
/// Find the first point that equals to the specified value.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <returns>Datapoint which matches the value. Null if there is no match.</returns>
public DataPoint FindByValue(double valueToFind, string useValue)
{
return FindByValue(valueToFind, useValue, 0);
}
/// <summary>
/// Find the first point that equals to the specified value.
/// </summary>
/// <param name="valueToFind">Point value to find.</param>
/// <returns>Datapoint which matches the value. Null if there is no match.</returns>
public DataPoint FindByValue(double valueToFind)
{
return FindByValue(valueToFind, "Y");
}
/// <summary>
/// Find point with the maximum value starting from specified index.
/// </summary>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <param name="startIndex">Index of the point to start looking from.</param>
/// <returns>Datapoint with the maximum value.</returns>
public DataPoint FindMaxByValue(string useValue, int startIndex)
{
//Check arguments
if (useValue == null)
throw new ArgumentNullException("useValue");
if (startIndex < 0 || startIndex >= this.Count)
throw new ArgumentOutOfRangeException("startIndex");
bool isYValue = useValue.StartsWith("Y", StringComparison.OrdinalIgnoreCase);
double maxValue = double.MinValue;
DataPoint maxPoint = null;
for (int i = startIndex; i < this.Count; i++)
{
DataPoint point = this[i];
// Skip empty points when searching for the Y values
if (point.IsEmpty && isYValue)
continue;
double pointValue = point.GetValueByName(useValue);
if (maxValue < pointValue)
{
maxValue = pointValue;
maxPoint = point;
}
}
return maxPoint;
}
/// <summary>
/// Find point with the maximum value.
/// </summary>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <returns>Datapoint with the maximum value.</returns>
public DataPoint FindMaxByValue(string useValue)
{
return FindMaxByValue(useValue, 0);
}
/// <summary>
/// Find data point with the maximum value.
/// </summary>
/// <returns>Datapoint with the maximum value.</returns>
public DataPoint FindMaxByValue()
{
return FindMaxByValue("Y");
}
/// <summary>
/// Find point with the Min value starting from specified index.
/// </summary>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <param name="startIndex">Index of the point to start looking from.</param>
/// <returns>Datapoint with the Min value.</returns>
public DataPoint FindMinByValue(string useValue, int startIndex)
{
if (useValue == null)
throw new ArgumentNullException("useValue");
if (startIndex < 0 || startIndex >= this.Count)
throw new ArgumentOutOfRangeException("startIndex");
bool isYValue = useValue.StartsWith("Y", StringComparison.OrdinalIgnoreCase);
double minValue = double.MaxValue;
DataPoint minPoint = null;
for (int i = startIndex; i < this.Count; i++)
{
DataPoint point = this[i];
// Skip empty points when searching for the Y values
if (point.IsEmpty && isYValue)
continue;
double pointValue = point.GetValueByName(useValue);
if (minValue > pointValue)
{
minValue = pointValue;
minPoint = point;
}
}
return minPoint;
}
/// <summary>
/// Find point with the Min value.
/// </summary>
/// <param name="useValue">Which point value to use (X, Y1, Y2,...).</param>
/// <returns>Datapoint with the Min value.</returns>
public DataPoint FindMinByValue(string useValue)
{
return FindMinByValue(useValue, 0);
}
/// <summary>
/// Find point with the Min value
/// </summary>
/// <returns>Datapoint with the Min value.</returns>
public DataPoint FindMinByValue()
{
return FindMinByValue("Y");
}
#endregion
#region Collection<T> overrides
/// <summary>
/// Initializes the specified item.
/// </summary>
/// <param name="item">The item.</param>
internal override void Initialize(DataPoint item)
{
DataPointInit(ref item);
base.Initialize(item);
}
#if Microsoft_CONTROL
/// <summary>
/// Removes all elements from the <see cref="T:System.Collections.ObjectModel.Collection`1"/>.
/// </summary>
protected override void ClearItems()
{
// Refresh Minimum and Maximum from data
// after recalc and set data
if (Common != null && Common.ChartPicture != null)
{
Common.ChartPicture.ResetMinMaxFromData();
}
base.ClearItems();
}
#endif
#endregion
}
/// <summary>
/// Stores values and properties of a DataPoint of a Series.
/// </summary>
[
SRDescription("DescriptionAttributeDataPoint_DataPoint"),
DefaultProperty("YValues"),
TypeConverter(Editors.DataPointConverter.Convertor)
]
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
#if !Microsoft_CONTROL
[Themeable(false)]
#endif
public class DataPoint : DataPointCustomProperties
{
#region Fields
// Point X value
private double _xValue;
// Point Y values
private double[] _yValue = new double[1];
// Pre calculated (during painting) relative position of data point
internal PointF positionRel = PointF.Empty;
// VSTS:199794 - Accessibility needs the last rendered label content to be exposed.
// The current label content evaluation is scattered over different chart types and cannot be isolated without risk of regression.
// This variable will cache the label content taken just before drawing.
internal string _lastLabelText = String.Empty;
#endregion
#region Constructors
/// <summary>
/// DataPoint object constructor.
/// </summary>
public DataPoint() : base(null, true)
{
_yValue = new double[1];
}
/// <summary>
/// DataPoint object constructor.
/// </summary>
/// <param name="series">series object, which the DataPoint belongs to.</param>
public DataPoint(Series series) : base(series, true)
{
// Create Y value(s) array
_yValue = new double[series.YValuesPerPoint];
_xValue = 0;
}
/// <summary>
/// DataPoint object constructor.
/// </summary>
/// <param name="xValue">X value.</param>
/// <param name="yValue">Y value.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public DataPoint(double xValue, double yValue)
: base(null, true)
{
// Set Y value
this._yValue = new double[1];
this._yValue[0] = yValue;
// Set X value
this._xValue = xValue;
}
/// <summary>
/// DataPoint object constructor.
/// </summary>
/// <param name="xValue">X value.</param>
/// <param name="yValues">Array of Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public DataPoint(double xValue, double[] yValues)
: base(null, true)
{
// Set Y value
this._yValue = yValues;
// Set X value
this._xValue = xValue;
}
/// <summary>
/// DataPoint object constructor.
/// </summary>
/// <remarks>
/// This method is only used during the Windows Forms serialization of the chart.
/// </remarks>
/// <param name="xValue">X value.</param>
/// <param name="yValues">String of comma separated Y values.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
[EditorBrowsable(EditorBrowsableState.Never)]
public DataPoint(double xValue, string yValues)
: base(null, true)
{
string[] values = yValues.Split(',');
// Create Y value(s) array
_yValue = new double[values.Length];
for (int index = 0; index < values.Length; index++)
{
_yValue[index] = CommonElements.ParseDouble(values[index], true);
}
// Set X value
this._xValue = xValue;
}
#endregion
#region Data point methods
/// <summary>
/// Sets the specified data point attribute to the specified value.
/// </summary>
/// <param name="obj">Attribute value.</param>
/// <param name="propertyName">Attribute name.</param>
/// <param name="format">Value format.</param>
internal void SetPointCustomProperty(
object obj,
string propertyName,
string format)
{
// Convert value to string
string stringValue = obj as string;
if(stringValue == null)
{
double doubleObj = double.NaN;
ChartValueType valueType = ChartValueType.Auto;
if(obj is DateTime)
{
doubleObj = ((DateTime)obj).ToOADate();
valueType = ChartValueType.Date;
}
else
{
doubleObj = this.ConvertValue(obj);
}
// Try converting to string
if( !double.IsNaN(doubleObj) )
{
try
{
stringValue = ValueConverter.FormatValue(
this.Chart,
this,
this.Tag,
doubleObj,
format,
valueType,
ChartElementType.DataPoint);
}
catch(FormatException)
{
// Use basic string converter
stringValue = obj.ToString();
}
}
else
{
// Use basic string converter
stringValue = obj.ToString();
}
}
// Assign data point attribute by name
if(stringValue.Length > 0)
{
if(String.Compare(propertyName, "AxisLabel", StringComparison.OrdinalIgnoreCase) == 0)
{
this.AxisLabel = stringValue;
}
else if (String.Compare(propertyName, "Tooltip", StringComparison.OrdinalIgnoreCase) == 0)
{
this.ToolTip = stringValue;
}
#if !Microsoft_CONTROL
else if(String.Compare(propertyName, "Url", StringComparison.OrdinalIgnoreCase) == 0)
{
this.Url = stringValue;
}
else if (String.Compare(propertyName, "PostBackValue", StringComparison.OrdinalIgnoreCase) == 0)
{
this.PostBackValue = stringValue;
}
else if (String.Compare(propertyName, "LabelUrl", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LabelUrl = stringValue;
}
else if (String.Compare(propertyName, "LabelPostBackValue", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LabelPostBackValue = stringValue;
}
else if (String.Compare(propertyName, "LegendUrl", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LegendUrl = stringValue;
}
else if (String.Compare(propertyName, "LegendPostBackValue", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LegendPostBackValue = stringValue;
}
#endif // !Microsoft_CONTROL
else if (String.Compare(propertyName, "Label", StringComparison.OrdinalIgnoreCase) == 0)
{
this.Label = stringValue;
}
else if (String.Compare(propertyName, "LegendTooltip", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LegendToolTip = stringValue;
}
else if (String.Compare(propertyName, "LegendText", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LegendText = stringValue;
}
else if (String.Compare(propertyName, "LabelToolTip", StringComparison.OrdinalIgnoreCase) == 0)
{
this.LabelToolTip = stringValue;
}
else
{
this[propertyName] = stringValue;
}
}
}
/// <summary>
/// Converts object to double.
/// </summary>
/// <param name="value">Object to convert.</param>
/// <returns>Double value.</returns>
private double ConvertValue(object value)
{
if(value == null)
{
return 0;
}
if(value is Double)
{
return (double)value;
}
else if(value is Single)
{
return (double)((float)value);
}
else if(value is Decimal)
{
return (double)((Decimal)value);
}
else if(value is Int32)
{
return (double)((Int32)value);
}
else if(value is UInt32)
{
return (double)((UInt32)value);
}
else if(value is Int64)
{
return (double)((Int64)value);
}
else if(value is UInt64)
{
return (double)((UInt64)value);
}
else if(value is Byte)
{
return (double)((Byte)value);
}
else if(value is SByte)
{
return (double)((SByte)value);
}
else if(value is Boolean)
{
return ((Boolean)value) ? 1.0 : 0.0;
}
else
{
string stringValue = "";
stringValue = value.ToString();
return CommonElements.ParseDouble(stringValue);
}
}
/// <summary>
/// Set X value and one or more Y values of the data point.
/// </summary>
/// <param name="xValue">X value of the data point.</param>
/// <param name="yValue">List of Y values of the data point.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "X and Y are cartesian coordinates and well understood")]
public void SetValueXY(object xValue, params object[] yValue)
{
// Check arguments
if (xValue == null)
throw new ArgumentNullException("xValue");
// Set Y value first
SetValueY(yValue);
// Check if parameters type matches with series type
Type paramType = xValue.GetType();
if(base.series != null)
{
base.series.CheckSupportedTypes(paramType);
}
// Save value in the array
if(paramType == typeof(String))
{
AxisLabel = (string)xValue;
}
else if(paramType == typeof(DateTime))
{
this._xValue = ((DateTime)xValue).ToOADate();
}
else
{
this._xValue = ConvertValue(xValue);
}
// Get Date or Time if required
if(base.series != null && xValue is DateTime)
{
if(base.series.XValueType == ChartValueType.Date)
{
DateTime time = new DateTime(
((DateTime)xValue).Year,
((DateTime)xValue).Month,
((DateTime)xValue).Day,
0,
0,
0,
0);
this._xValue = time.ToOADate();
}
else if(base.series.XValueType == ChartValueType.Time)
{
DateTime time = new DateTime(
1899,
12,
30,
((DateTime)xValue).Hour,
((DateTime)xValue).Minute,
((DateTime)xValue).Second,
((DateTime)xValue).Millisecond);
this._xValue = time.ToOADate();
}
}
// Check if one of Y values are not avilable
bool empty = false;
foreach(double d in this._yValue)
{
if(double.IsNaN(d))
{
empty = true;
break;
}
}
// Set point empty flag and values to zero
if(empty)
{
this.IsEmpty = true;
for(int valueIndex = 0; valueIndex < this._yValue.Length; valueIndex++)
{
this._yValue[valueIndex] = 0.0;
}
}
}
/// <summary>
/// Set one or more Y values of the data point.
/// </summary>
/// <param name="yValue">List of Y values of the data point.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
Justification = "Y is a cartesian coordinate and well understood")]
public void SetValueY(params object[] yValue)
{
// Check arguments
if (yValue == null)
throw new ArgumentNullException("yValue");
// Check number of parameters. Should be more than 0 and
if(yValue.Length == 0 || (base.series != null && yValue.Length > base.series.YValuesPerPoint))
throw(new ArgumentOutOfRangeException("yValue", SR.ExceptionDataPointYValuesSettingCountMismatch(base.series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture))));
// Check if there is a Null Y value
for( int i = 0 ; i < yValue.Length ; i++ )
{
if(yValue[i] == null || yValue[i] is System.DBNull)
{
yValue[i] = 0.0;
if(i == 0)
{
this.IsEmpty = true;
}
}
}
// Check if parameters type matches with series type
Type paramType = yValue[0].GetType();
if(base.series != null)
{
base.series.CheckSupportedTypes(paramType);
}
// Make sure the Y values array is big enough
if (this._yValue.Length < yValue.Length)
{
this._yValue = new double[yValue.Length];
}
// Save value in the array
if(paramType == typeof(String))
{
try
{
for (int i = 0; i < yValue.Length; i++)
{
this._yValue[i] = CommonElements.ParseDouble((string)yValue[i]);
}
}
catch
{
// Get reference to the chart object
if (Common!=null && Common.ChartPicture!=null && Common.ChartPicture.SuppressExceptions)
{
this.IsEmpty = true;
for (int i = 0; i < yValue.Length; i++)
{
yValue[i] = 0.0;
}
}
else
{
throw (new ArgumentException( SR.ExceptionDataPointYValueStringFormat));
}
}
}
else if(paramType == typeof(DateTime))
{
for( int i = 0 ; i < yValue.Length ; i++ )
{
if(yValue[i] == null ||
(yValue[i] is double && ((double)yValue[i]) == 0.0) )
{
this._yValue[i] = DateTime.Now.ToOADate();
}
else
{
this._yValue[i] = ((DateTime)yValue[i]).ToOADate();
}
}
}
else
{
for( int i = 0 ; i < yValue.Length ; i++ )
{
this._yValue[i] = ConvertValue(yValue[i]);
}
}
// Get Date or Time if required
if(base.series != null)
{
for( int i = 0 ; i < yValue.Length ; i++ )
{
if(yValue[i] == null ||
(yValue[i] is double && ((double)yValue[i]) == 0.0) )
{
if(base.series.YValueType == ChartValueType.Date)
{
this._yValue[i] = Math.Floor(this._yValue[i]);
}
else if(base.series.YValueType == ChartValueType.Time)
{
this._yValue[i] = this._xValue - Math.Floor(this._yValue[i]);
}
}
else
{
if(base.series.YValueType == ChartValueType.Date)
{
DateTime yDate;
if (yValue[i] is DateTime)
yDate = (DateTime)yValue[i];
else if (yValue[i] is Double)
yDate = DateTime.FromOADate((Double)yValue[i]);
else
yDate = Convert.ToDateTime(yValue[i], CultureInfo.InvariantCulture); //This will throw an exception in case when the yValue type is not compatible with the DateTime
DateTime date = new DateTime(
yDate.Year,
yDate.Month,
yDate.Day,
0,
0,
0,
0);
this._yValue[i] = date.ToOADate();
}
else if (base.series.YValueType == ChartValueType.Time)
{
DateTime yTime;
if (yValue[i] is DateTime)
yTime = (DateTime)yValue[i];
if (yValue[i] is Double)
yTime = DateTime.FromOADate((Double)yValue[i]);
else
yTime = Convert.ToDateTime(yValue[i], CultureInfo.InvariantCulture); //This will throw an exception in case when the yValue type is not compatible with the DateTime
DateTime time = new DateTime(
1899,
12,
30,
yTime.Hour,
yTime.Minute,
yTime.Second,
yTime.Millisecond);
this._yValue[i] = time.ToOADate();
}
}
}
}
}
/// <summary>
/// Creates an exact copy of this DataPoint object.
/// </summary>
/// <returns>An exact copy of this DataPoint object.</returns>
public DataPoint Clone()
{
// Create new data point
DataPoint clonePoint = new DataPoint();
// Reset series pointer
clonePoint.series = null;
clonePoint.pointCustomProperties = this.pointCustomProperties;
// Copy values
clonePoint._xValue = this.XValue;
clonePoint._yValue = new double[this._yValue.Length];
this._yValue.CopyTo(clonePoint._yValue, 0);
clonePoint.tempColorIsSet = this.tempColorIsSet;
clonePoint.isEmptyPoint = this.isEmptyPoint;
// Copy properties
foreach(object key in this.properties.Keys)
{
clonePoint.properties.Add(key, this.properties[key]);
}
return clonePoint;
}
/// <summary>
/// Resize Y values array.
/// </summary>
/// <param name="newSize">New number of Y values in array.</param>
internal void ResizeYValueArray(int newSize)
{
// Create new array
double[] newArray = new Double[newSize];
// Copy elements
if(_yValue != null)
{
for(int i = 0; i < ((_yValue.Length < newSize) ? _yValue.Length : newSize); i++)
{
newArray[i] = _yValue[i];
}
}
_yValue = newArray;
}
/// <summary>
/// Helper function, which returns point value by it's name.
/// </summary>
/// <param name="valueName">Point value names. X, Y, Y2,...</param>
/// <returns>Point value.</returns>
public double GetValueByName(string valueName)
{
// Check arguments
if (valueName == null)
throw new ArgumentNullException("valueName");
valueName = valueName.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
if(String.Compare(valueName, "X", StringComparison.Ordinal) == 0)
{
return this.XValue;
}
else if (valueName.StartsWith("Y", StringComparison.Ordinal))
{
if(valueName.Length == 1)
{
return this.YValues[0];
}
else
{
int yIndex = 0;
try
{
yIndex = Int32.Parse(valueName.Substring(1), System.Globalization.CultureInfo.InvariantCulture) - 1;
}
catch(System.Exception)
{
throw(new ArgumentException( SR.ExceptionDataPointValueNameInvalid, "valueName"));
}
if(yIndex < 0)
{
throw(new ArgumentException( SR.ExceptionDataPointValueNameYIndexIsNotPositive, "valueName"));
}
if(yIndex >= this.YValues.Length)
{
throw(new ArgumentException( SR.ExceptionDataPointValueNameYIndexOutOfRange, "valueName"));
}
return this.YValues[yIndex];
}
}
else
{
throw(new ArgumentException( SR.ExceptionDataPointValueNameInvalid, "valueName"));
}
}
/// <summary>
/// Replaces predefined keyword inside the string with their values.
/// </summary>
/// <param name="strOriginal">Original string with keywords.</param>
/// <returns>Modified string.</returns>
internal override string ReplaceKeywords(string strOriginal)
{
// Nothing to process
if(strOriginal == null || strOriginal.Length == 0)
return strOriginal;
// Replace all "\n" strings with '\n' character
string result = strOriginal;
result = result.Replace("\\n", "\n");
// #LABEL - point label
result = result.Replace(KeywordName.Label, this.Label);
// #LEGENDTEXT - series name
result = result.Replace(KeywordName.LegendText, this.LegendText);
// #AXISLABEL - series name
result = result.Replace(KeywordName.AxisLabel, this.AxisLabel);
// #CUSTOMPROPERTY - one of the custom properties by name
result = DataPoint.ReplaceCustomPropertyKeyword(result, this);
if(this.series != null)
{
// #INDEX - point index
result = result.Replace(KeywordName.Index, this.series.Points.IndexOf(this).ToString(System.Globalization.CultureInfo.InvariantCulture));
// Replace series keywords
result = this.series.ReplaceKeywords(result);
// #PERCENT - percentage of Y value from total
result = this.series.ReplaceOneKeyword(
this.Chart,
this,
this.Tag,
ChartElementType.DataPoint,
result,
KeywordName.Percent,
(this.YValues[0]/(this.series.GetTotalYValue())),
ChartValueType.Double,
"P");
// #VAL[X] - point value X, Y, Y2, ...
if(this.series.XValueType == ChartValueType.String)
{
result = result.Replace(KeywordName.ValX, this.AxisLabel);
}
else
{
result = this.series.ReplaceOneKeyword(
this.Chart,
this,
this.Tag,
ChartElementType.DataPoint,
result,
KeywordName.ValX,
this.XValue,
this.series.XValueType,
"");
}
// remove keywords #VAL? for unexisted Y value indices
for (int index = this.YValues.Length; index <= 7; index++)
{
result = this.RemoveOneKeyword(result, KeywordName.ValY + index + 1, SR.FormatErrorString);
}
for(int index = 1; index <= this.YValues.Length; index++)
{
result = this.series.ReplaceOneKeyword(
this.Chart,
this,
this.Tag,
ChartElementType.DataPoint,
result,
KeywordName.ValY + index,
this.YValues[index - 1],
this.series.YValueType,
"");
}
result = this.series.ReplaceOneKeyword(
Chart,
this,
this.Tag,
ChartElementType.DataPoint,
result,
KeywordName.ValY,
this.YValues[0],
this.series.YValueType,
"");
result = this.series.ReplaceOneKeyword(
Chart,
this,
this.Tag,
ChartElementType.DataPoint,
result,
KeywordName.Val,
this.YValues[0],
this.series.YValueType,
"");
}
return result;
}
/// <summary>
/// Removes one keyword from format string.
/// </summary>
/// <param name="strOriginal">Original format string</param>
/// <param name="keyword">The keyword</param>
/// <param name="strToReplace">String to replace the keyword.</param>
/// <returns>Modified format string</returns>
private string RemoveOneKeyword(string strOriginal, string keyword, string strToReplace)
{
string result = strOriginal;
int keyIndex = -1;
while ((keyIndex = result.IndexOf(keyword, StringComparison.Ordinal)) != -1)
{
// Get optional format
int keyEndIndex = keyIndex + keyword.Length;
if (result.Length > keyEndIndex && result[keyEndIndex] == '{')
{
int formatEnd = result.IndexOf('}', keyEndIndex);
if (formatEnd == -1)
{
throw (new InvalidOperationException(SR.ExceptionDataSeriesKeywordFormatInvalid(result)));
}
keyEndIndex = formatEnd + 1;
}
// Remove keyword string (with optional format)
result = result.Remove(keyIndex, keyEndIndex - keyIndex);
if (!String.IsNullOrEmpty(strToReplace))
{
result = result.Insert(keyIndex, strToReplace);
}
}
return result;
}
/// <summary>
/// Replaces all "#CUSTOMPROPERTY(XXX)" (where XXX is the custom attribute name)
/// keywords in the string provided.
/// </summary>
/// <param name="originalString">String where the keyword need to be replaced.</param>
/// <param name="properties">DataPoint or Series properties class.</param>
/// <returns>Converted string.</returns>
internal static string ReplaceCustomPropertyKeyword(string originalString, DataPointCustomProperties properties)
{
string result = originalString;
int keyStartIndex = -1;
while ((keyStartIndex = result.IndexOf(KeywordName.CustomProperty, StringComparison.Ordinal)) >= 0)
{
string attributeValue = string.Empty;
string attributeName = string.Empty;
// Forward to the end of the keyword
int keyEndIndex = keyStartIndex + KeywordName.CustomProperty.Length;
// An opening bracket '(' must follow
if (result.Length > keyEndIndex && result[keyEndIndex] == '(')
{
++keyEndIndex;
int attributeNameStartIndex = keyEndIndex;
// Search for the closing bracket
int closingBracketIndex = result.IndexOf(')', keyEndIndex);
if (closingBracketIndex >= keyEndIndex)
{
keyEndIndex = closingBracketIndex + 1;
attributeName = result.Substring(attributeNameStartIndex, keyEndIndex - attributeNameStartIndex - 1);
// Get attribute value
if (properties.IsCustomPropertySet(attributeName))
{
attributeValue = properties.GetCustomProperty(attributeName);
}
else
{
// In case of the DataPoint check if the attribute is set in the parent series
DataPoint dataPoint = properties as DataPoint;
if (dataPoint != null && dataPoint.series != null)
{
if (dataPoint.series.IsCustomPropertySet(attributeName))
{
attributeValue = dataPoint.series.GetCustomProperty(attributeName);
}
}
}
}
}
// Remove keyword string with attribute name
result = result.Remove(keyStartIndex, keyEndIndex - keyStartIndex);
// Insert value of the custom attribute
result = result.Insert(keyStartIndex, attributeValue);
}
return result;
}
/// <summary>
/// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </summary>
/// <returns>
/// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </returns>
internal override string ToStringInternal()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat(CultureInfo.CurrentCulture, "{{X={0}, ", XValue);
if (YValues.Length == 1)
{
sb.AppendFormat(CultureInfo.CurrentCulture, "Y={0}", YValues[0]);
}
else
{
sb.Append("Y={");
for (int i = 0; i < YValues.Length; i++)
if (i == 0)
sb.AppendFormat(CultureInfo.CurrentCulture, "{0}", YValues[i]);
else
sb.AppendFormat(CultureInfo.CurrentCulture, ", {0}", YValues[i]);
sb.Append("}");
}
sb.Append("}");
return sb.ToString();
}
#endregion
#region DataPoint Properties
/// <summary>
/// X value of the data point.
/// </summary>
[
SRCategory("CategoryAttributeData"),
Bindable(true),
SRDescription("DescriptionAttributeDataPoint_XValue"),
TypeConverter(typeof(DataPointValueConverter)),
DefaultValue(typeof(double), "0.0"),
#if Microsoft_CONTROL
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
#else
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public double XValue
{
get
{
return _xValue;
}
set
{
_xValue = value;
this.Invalidate(false);
}
}
/// <summary>
/// List of Y values of the data point.
/// </summary>
[
SRCategory("CategoryAttributeData"),
SRDescription("DescriptionAttributeDataPoint_YValues"),
Bindable(true),
#if Microsoft_CONTROL
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
#else
PersistenceMode(PersistenceMode.Attribute),
#endif
TypeConverter(typeof(DoubleArrayConverter)),
Editor(typeof(UITypeEditor), typeof(UITypeEditor)),
RefreshProperties(RefreshProperties.All),
SerializationVisibilityAttribute(SerializationVisibility.Attribute)
]
[SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
public double[] YValues
{
get
{
return _yValue;
}
set
{
if(value == null)
{
// Clear array data
for(int i=0; i < _yValue.Length; i++)
{
_yValue[i] = 0;
}
}
else
{
_yValue = value;
}
this.Invalidate(false);
}
}
/// <summary>
/// A flag which indicates whether the data point is empty.
/// </summary>
[
SRCategory("CategoryAttributeData"),
Bindable(true),
SRDescription("DescriptionAttributeDataPoint_Empty"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
DefaultValue(false)
]
public bool IsEmpty
{
get
{
return base.isEmptyPoint;
}
set
{
base.isEmptyPoint = value;
this.Invalidate(true);
}
}
/// <summary>
/// Name of the data point. This field is reserved for internal use only.
/// </summary>
[
SRCategory("CategoryAttributeData"),
Bindable(true),
Browsable(false),
SRDescription("DescriptionAttributeDataPoint_Name"),
DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
SerializationVisibilityAttribute(SerializationVisibility.Hidden)
]
public override string Name
{
get
{
return "DataPoint";
}
set
{
//Dont call the base method - the names don't need to be unique
}
}
#endregion
}
/// <summary>
/// Stores properties of one Data Point and Data series.
/// </summary>
[
SRDescription("DescriptionAttributeDataPointCustomProperties_DataPointCustomProperties"),
DefaultProperty("LabelStyle"),
TypeConverter(Editors.DataPointCustomPropertiesConverter.Convertor)
]
#if Microsoft_CONTROL
public class DataPointCustomProperties : 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 DataPointCustomProperties : ChartNamedElement, IChartMapArea
#endif
{
#region Fields and enumerations
// True indicates data point properties. Otherwise - series.
internal bool pointCustomProperties = true;
// Reference to the data point series
internal Series series = null;
// Storage for the custom properties names/values
internal Hashtable properties = new Hashtable();
// Flag indicating that temp. color was set
internal bool tempColorIsSet = false;
// Design time custom properties data
internal CustomProperties customProperties = null;
// IsEmpty point indicator
internal bool isEmptyPoint = false;
#endregion
#region Constructors
/// <summary>
/// DataPointCustomProperties constructor.
/// </summary>
public DataPointCustomProperties()
{
// Initialize the data series
this.series = null;
this.customProperties = new CustomProperties(this);
}
/// <summary>
/// DataPointCustomProperties constructor.
/// </summary>
/// <param name="series">The series which the data point belongs to.</param>
/// <param name="pointProperties">Indicates whether this is a data point custom properties.</param>
public DataPointCustomProperties(Series series, bool pointProperties): base( series, String.Empty)
{
// Initialize the data series
this.series = series;
this.pointCustomProperties = pointProperties;
this.customProperties = new CustomProperties(this);
}
#endregion
#region Custom Properties methods
/// <summary>
/// Checks if custom property with specified name was set.
/// </summary>
/// <param name="name">Name of the custom property to check.</param>
/// <returns>True if custom property was set.</returns>
virtual public bool IsCustomPropertySet(string name)
{
return properties.ContainsKey(name);
}
/// <summary>
/// Checks if the custom property with specified name was set.
/// </summary>
/// <param name="property">The CommonCustomProperties object to check for.</param>
/// <returns>True if attribute was set.</returns>
internal bool IsCustomPropertySet(CommonCustomProperties property)
{
return properties.ContainsKey((int)property);
}
/// <summary>
/// Delete the data point custom property with the specified name.
/// </summary>
/// <param name="name">Name of the property to delete.</param>
virtual public void DeleteCustomProperty(string name)
{
if(name == null)
{
throw (new ArgumentNullException(SR.ExceptionAttributeNameIsEmpty));
}
// Check if trying to delete the common attribute
string[] AttributesNames = CommonCustomProperties.GetNames(typeof(CommonCustomProperties));
foreach(string commonName in AttributesNames)
{
if(name == commonName)
{
DeleteCustomProperty((CommonCustomProperties)Enum.Parse(typeof(CommonCustomProperties), commonName));
}
}
// Remove attribute
properties.Remove(name);
}
/// <summary>
/// Delete Data Point attribute with specified name.
/// </summary>
/// <param name="property">ID of the attribute to delete.</param>
internal void DeleteCustomProperty(CommonCustomProperties property)
{
// Check if trying to delete the common attribute from the series
if(!this.pointCustomProperties)
{
throw(new ArgumentException( SR.ExceptionAttributeUnableToDelete));
}
// Remove attribute
properties.Remove((int)property);
}
/// <summary>
/// Gets the data point custom property with the specified name.
/// </summary>
/// <param name="name">Name of the property to get.</param>
/// <returns>Returns the data point custom property with the specified name. If the requested one is not set,
/// the default custom property of the data series will be returned.</returns>
virtual public string GetCustomProperty(string name)
{
if(!IsCustomPropertySet(name) && this.pointCustomProperties)
{
// Check if we are in serialization mode
bool serializing = false;
if(Chart != null && Chart.serializing)
{
serializing = true;
}
if(!serializing)
{
if(this.isEmptyPoint)
{
// Return empty point properties from series
return (string)series.EmptyPointStyle.properties[name];
}
// Return properties from series
return (string)series.properties[name];
}
else
{
// Return default properties
return (string)Series.defaultCustomProperties[name];
}
}
return (string)properties[name];
}
/// <summary>
/// Checks if data is currently serialized.
/// </summary>
/// <returns>True if serialized.</returns>
internal bool IsSerializing()
{
// Check if series object is provided
if(series == null)
{
return true;
}
// Check if we are in serialization mode
if(Chart != null)
{
return Chart.serializing;
}
else
{
return false;
}
}
/// <summary>
/// Returns an attribute object of the Data Point. If required attribute is not set
/// in the Data Point the default attribute of the Data series is returned.
/// </summary>
/// <param name="attrib">Attribute name ID.</param>
/// <returns>Attribute value.</returns>
internal object GetAttributeObject(CommonCustomProperties attrib)
{
// Get series properties
if(!this.pointCustomProperties || series == null)
{
return properties[(int)attrib];
}
// Get data point properties
if(properties.Count == 0 || !IsCustomPropertySet(attrib))
{
// Check if we are in serialization mode
bool serializing = false;
if(Chart != null)
{
serializing = Chart.serializing;
}
if(!serializing)
{
if(this.isEmptyPoint)
{
// Return empty point properties from series
return series.EmptyPointStyle.properties[(int)attrib];
}
// Return properties from series
return series.properties[(int)attrib];
}
else
{
// Return default properties
return Series.defaultCustomProperties.properties[(int)attrib];
}
}
return properties[(int)attrib];
}
/// <summary>
/// Sets a custom property of the data point.
/// </summary>
/// <param name="name">Property name.</param>
/// <param name="propertyValue">Property value.</param>
virtual public void SetCustomProperty(string name, string propertyValue)
{
properties[name] = propertyValue;
}
/// <summary>
/// Sets an attribute of the Data Point as an object.
/// </summary>
/// <param name="attrib">Attribute name ID.</param>
/// <param name="attributeValue">Attribute new value.</param>
internal void SetAttributeObject(CommonCustomProperties attrib, object attributeValue)
{
properties[(int)attrib] = attributeValue;
}
/// <summary>
/// Set the default properties of the data point.
/// <param name="clearAll">Indicates that previous properties must be cleared.</param>
/// </summary>
virtual public void SetDefault(bool clearAll)
{
// If setting defaults for the data series - clear all properties and initialize common one
if(!this.pointCustomProperties)
{
if(clearAll)
{
properties.Clear();
}
// !!! IMPORTANT !!!
// After changing the default value of the common attribute you must also
// change the DefaultAttribute of the property representing this attribute.
if(!IsCustomPropertySet(CommonCustomProperties.ToolTip))
SetAttributeObject(CommonCustomProperties.ToolTip, "");
if(!IsCustomPropertySet(CommonCustomProperties.LegendToolTip))
SetAttributeObject(CommonCustomProperties.LegendToolTip, "");
if(!IsCustomPropertySet(CommonCustomProperties.Color))
SetAttributeObject(CommonCustomProperties.Color, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.IsValueShownAsLabel))
SetAttributeObject(CommonCustomProperties.IsValueShownAsLabel, false);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerStyle))
SetAttributeObject(CommonCustomProperties.MarkerStyle, MarkerStyle.None);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerSize))
SetAttributeObject(CommonCustomProperties.MarkerSize, 5);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerImage))
SetAttributeObject(CommonCustomProperties.MarkerImage, "");
if(!IsCustomPropertySet(CommonCustomProperties.Label))
SetAttributeObject(CommonCustomProperties.Label, "");
if(!IsCustomPropertySet(CommonCustomProperties.BorderWidth))
SetAttributeObject(CommonCustomProperties.BorderWidth, 1);
if(!IsCustomPropertySet(CommonCustomProperties.BorderDashStyle))
SetAttributeObject(CommonCustomProperties.BorderDashStyle, ChartDashStyle.Solid);
if(!IsCustomPropertySet(CommonCustomProperties.AxisLabel))
SetAttributeObject(CommonCustomProperties.AxisLabel, "");
if(!IsCustomPropertySet(CommonCustomProperties.LabelFormat))
SetAttributeObject(CommonCustomProperties.LabelFormat, "");
if(!IsCustomPropertySet(CommonCustomProperties.BorderColor))
SetAttributeObject(CommonCustomProperties.BorderColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.BackImage))
SetAttributeObject(CommonCustomProperties.BackImage, "");
if(!IsCustomPropertySet(CommonCustomProperties.BackImageWrapMode))
SetAttributeObject(CommonCustomProperties.BackImageWrapMode, ChartImageWrapMode.Tile);
if(!IsCustomPropertySet(CommonCustomProperties.BackImageAlignment))
SetAttributeObject(CommonCustomProperties.BackImageAlignment, ChartImageAlignmentStyle.TopLeft);
if(!IsCustomPropertySet(CommonCustomProperties.BackImageTransparentColor))
SetAttributeObject(CommonCustomProperties.BackImageTransparentColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.BackGradientStyle))
SetAttributeObject(CommonCustomProperties.BackGradientStyle, GradientStyle.None);
if(!IsCustomPropertySet(CommonCustomProperties.BackSecondaryColor))
SetAttributeObject(CommonCustomProperties.BackSecondaryColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.BackHatchStyle))
SetAttributeObject(CommonCustomProperties.BackHatchStyle, ChartHatchStyle.None);
if(!IsCustomPropertySet(CommonCustomProperties.Font))
SetAttributeObject(CommonCustomProperties.Font, null);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerImageTransparentColor))
SetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerColor))
SetAttributeObject(CommonCustomProperties.MarkerColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerBorderColor))
SetAttributeObject(CommonCustomProperties.MarkerBorderColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.MarkerBorderWidth))
SetAttributeObject(CommonCustomProperties.MarkerBorderWidth, 1);
if(!IsCustomPropertySet(CommonCustomProperties.MapAreaAttributes))
SetAttributeObject(CommonCustomProperties.MapAreaAttributes, "");
if (!IsCustomPropertySet(CommonCustomProperties.PostBackValue))
SetAttributeObject(CommonCustomProperties.PostBackValue, "");
if (!IsCustomPropertySet(CommonCustomProperties.LabelForeColor))
SetAttributeObject(CommonCustomProperties.LabelForeColor, Color.Black);
if (!IsCustomPropertySet(CommonCustomProperties.LabelAngle))
SetAttributeObject(CommonCustomProperties.LabelAngle, 0);
if (!IsCustomPropertySet(CommonCustomProperties.LabelToolTip))
SetAttributeObject(CommonCustomProperties.LabelToolTip, "");
if(!IsCustomPropertySet(CommonCustomProperties.LabelUrl))
SetAttributeObject(CommonCustomProperties.LabelUrl, "");
if (!IsCustomPropertySet(CommonCustomProperties.LabelPostBackValue))
SetAttributeObject(CommonCustomProperties.LabelPostBackValue, "");
if (!IsCustomPropertySet(CommonCustomProperties.LabelMapAreaAttributes))
SetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes, "");
if(!IsCustomPropertySet(CommonCustomProperties.LabelBackColor))
SetAttributeObject(CommonCustomProperties.LabelBackColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.LabelBorderWidth))
SetAttributeObject(CommonCustomProperties.LabelBorderWidth, 1);
if(!IsCustomPropertySet(CommonCustomProperties.LabelBorderDashStyle))
SetAttributeObject(CommonCustomProperties.LabelBorderDashStyle, ChartDashStyle.Solid);
if(!IsCustomPropertySet(CommonCustomProperties.LabelBorderColor))
SetAttributeObject(CommonCustomProperties.LabelBorderColor, Color.Empty);
if(!IsCustomPropertySet(CommonCustomProperties.Url))
SetAttributeObject(CommonCustomProperties.Url, "");
if(!IsCustomPropertySet(CommonCustomProperties.LegendUrl))
SetAttributeObject(CommonCustomProperties.LegendUrl, "");
if (!IsCustomPropertySet(CommonCustomProperties.LegendPostBackValue))
SetAttributeObject(CommonCustomProperties.LegendPostBackValue, "");
if (!IsCustomPropertySet(CommonCustomProperties.LegendText))
SetAttributeObject(CommonCustomProperties.LegendText, "");
if(!IsCustomPropertySet(CommonCustomProperties.LegendMapAreaAttributes))
SetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes, "");
if(!IsCustomPropertySet(CommonCustomProperties.IsVisibleInLegend))
SetAttributeObject(CommonCustomProperties.IsVisibleInLegend, true);
}
// If setting defaults for the data point - clear all properties
else
{
properties.Clear();
}
}
#endregion
#region DataPointCustomProperties Properties
/// <summary>
/// Indexer of the custom properties. Returns the DataPointCustomProperties object by index.
/// </summary>
/// <param name="index">Index of the custom property.</param>
public string this[int index]
{
get
{
int currentIndex = 0;
foreach(object key in properties.Keys)
{
if(currentIndex == index)
{
string keyStr = key as string;
if (keyStr != null)
{
return keyStr;
}
else if (key is int)
{
return Enum.GetName(typeof(CommonCustomProperties), key);
}
return key.ToString();
}
++currentIndex;
}
// we can't throw IndexOutOfRangeException here, it is reserved
// by the CLR.
throw (new InvalidOperationException());
}
}
/// <summary>
/// Indexer of the custom properties. Returns the DataPointCustomProperties object by name.
/// </summary>
/// <param name="name">Name of the custom property.</param>
public string this[string name]
{
get
{
// If attribute is not set in data point - try getting it from the series
if(!IsCustomPropertySet(name) && this.pointCustomProperties)
{
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.properties[name];
}
return (string)series.properties[name];
}
return (string)properties[name];
}
set
{
properties[name] = value;
this.Invalidate(true);
}
}
/// <summary>
/// The text of the data point label.
/// </summary>
[
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
SRCategory("CategoryAttributeLabel"),
Bindable(true),
SRDescription("DescriptionAttributeLabel"),
]
virtual public string Label
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.Label))
{
return (string)GetAttributeObject(CommonCustomProperties.Label);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Label);
}
return series.label;
}
}
else
{
return series.label;
}
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
if (this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.Label, value);
else
series.label = value;
this.Invalidate(true);
}
}
/// <summary>
/// The text of X axis label for the data point.
/// </summary>
[
SRCategory("CategoryAttributeMisc"),
Bindable(true),
SRDescription("DescriptionAttributeAxisLabel"),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
virtual public string AxisLabel
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.AxisLabel))
{
return (string)GetAttributeObject(CommonCustomProperties.AxisLabel);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.AxisLabel);
}
return series.axisLabel;
}
}
else
{
return series.axisLabel;
}
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.AxisLabel, value);
else
series.axisLabel = value;
// Set flag that there are non-empy axis labels in series or points
if(value.Length > 0 && series != null)
{
series.noLabelsInPoints = false;
}
this.Invalidate(false);
}
}
/// <summary>
/// Format string of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeLabel"),
Bindable(true),
SRDescription("DescriptionAttributeLabelFormat"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
]
public string LabelFormat
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelFormat))
{
return (string)GetAttributeObject(CommonCustomProperties.LabelFormat);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelFormat);
}
return series.labelFormat;
}
}
else
{
return series.labelFormat;
}
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelFormat, value);
else
series.labelFormat = value;
this.Invalidate(false);
}
}
/// <summary>
/// A flag which indicates whether to show the data point's value on the label.
/// </summary>
[
SRCategory("CategoryAttributeLabel"),
Bindable(true),
SRDescription("DescriptionAttributeShowLabelAsValue"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public bool IsValueShownAsLabel
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.IsValueShownAsLabel))
{
return (bool)GetAttributeObject(CommonCustomProperties.IsValueShownAsLabel);
}
else
{
if(IsSerializing())
{
return false;
}
if(this.isEmptyPoint)
{
return (bool)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.IsValueShownAsLabel);
}
return series.showLabelAsValue;
}
}
else
{
return series.showLabelAsValue;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.IsValueShownAsLabel, value);
else
series.showLabelAsValue = value;
this.Invalidate(false);
}
}
/// <summary>
/// Color of the data point.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeColor4"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color Color
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.Color))
{
return (Color)GetAttributeObject(CommonCustomProperties.Color);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Color);
}
return series.color;
}
}
else
{
return series.color;
}
}
set
{
// Remove the temp color flag
this.tempColorIsSet = false;
if(value == Color.Empty && this.pointCustomProperties)
{
DeleteCustomProperty(CommonCustomProperties.Color);
}
else
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.Color, value);
else
series.color = value;
this.Invalidate(true);
}
}
}
/// <summary>
/// Border color of the data point.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBorderColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BorderColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BorderColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.BorderColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderColor);
}
return series.borderColor;
}
}
else
{
return series.borderColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BorderColor, value);
else
series.borderColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Border style of the data point.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBorderDashStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartDashStyle BorderDashStyle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BorderDashStyle))
{
return (ChartDashStyle)GetAttributeObject(CommonCustomProperties.BorderDashStyle);
}
else
{
if(IsSerializing())
{
return ChartDashStyle.Solid;
}
if(this.isEmptyPoint)
{
return (ChartDashStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderDashStyle);
}
return series.borderDashStyle;
}
}
else
{
return series.borderDashStyle;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BorderDashStyle, value);
else
series.borderDashStyle = value;
this.Invalidate(true);
}
}
/// <summary>
/// Border width of the data point.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBorderWidth"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int BorderWidth
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BorderWidth))
{
return (int)GetAttributeObject(CommonCustomProperties.BorderWidth);
}
else
{
if(IsSerializing())
{
return 1;
}
if(this.isEmptyPoint)
{
return (int)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderWidth);
}
return series.borderWidth;
}
}
else
{
return series.borderWidth;
}
}
set
{
if(value < 0)
{
throw (new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsNotPositive));
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BorderWidth, value);
else
series.borderWidth = value;
this.Invalidate(true);
}
}
/// <summary>
/// Background image of the data point.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBackImage"),
Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
]
public string BackImage
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackImage))
{
return (string)GetAttributeObject(CommonCustomProperties.BackImage);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImage);
}
return series.backImage;
}
}
else
{
return series.backImage;
}
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackImage, value);
else
series.backImage = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the drawing mode of the background image.
/// </summary>
/// <value>
/// A <see cref="ChartImageWrapMode"/> value that defines the drawing mode of the image.
/// </value>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeImageWrapMode"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartImageWrapMode BackImageWrapMode
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackImageWrapMode))
{
return (ChartImageWrapMode)GetAttributeObject(CommonCustomProperties.BackImageWrapMode);
}
else
{
if(IsSerializing())
{
return ChartImageWrapMode.Tile;
}
if(this.isEmptyPoint)
{
return (ChartImageWrapMode)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageWrapMode);
}
return series.backImageWrapMode;
}
}
else
{
return series.backImageWrapMode;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackImageWrapMode, value);
else
series.backImageWrapMode = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets a color which will be replaced with a transparent color while drawing the background image.
/// </summary>
/// <value>
/// A <see cref="Color"/> value which will be replaced with a transparent color while drawing the image.
/// </value>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
NotifyParentPropertyAttribute(true),
SRDescription("DescriptionAttributeImageTransparentColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BackImageTransparentColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackImageTransparentColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.BackImageTransparentColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageTransparentColor);
}
return series.backImageTransparentColor;
}
}
else
{
return series.backImageTransparentColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackImageTransparentColor, value);
else
series.backImageTransparentColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the alignment of the background image which is used by ClampUnscale drawing mode.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
NotifyParentPropertyAttribute(true),
SRDescription("DescriptionAttributeBackImageAlign"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartImageAlignmentStyle BackImageAlignment
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackImageAlignment))
{
return (ChartImageAlignmentStyle)GetAttributeObject(CommonCustomProperties.BackImageAlignment);
}
else
{
if(IsSerializing())
{
return ChartImageAlignmentStyle.TopLeft;
}
if(this.isEmptyPoint)
{
return (ChartImageAlignmentStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageAlignment);
}
return series.backImageAlignment;
}
}
else
{
return series.backImageAlignment;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackImageAlignment, value);
else
series.backImageAlignment = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the background gradient style.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBackGradientStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
]
public GradientStyle BackGradientStyle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackGradientStyle))
{
return (GradientStyle)GetAttributeObject(CommonCustomProperties.BackGradientStyle);
}
else
{
if(IsSerializing())
{
return GradientStyle.None;
}
if(this.isEmptyPoint)
{
return (GradientStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackGradientStyle);
}
return series.backGradientStyle;
}
}
else
{
return series.backGradientStyle;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackGradientStyle, value);
else
series.backGradientStyle = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the secondary background color.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBackSecondaryColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BackSecondaryColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackSecondaryColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.BackSecondaryColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackSecondaryColor);
}
return series.backSecondaryColor;
}
}
else
{
return series.backSecondaryColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackSecondaryColor, value);
else
series.backSecondaryColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the background hatch style.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBackHatchStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
]
public ChartHatchStyle BackHatchStyle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.BackHatchStyle))
{
return (ChartHatchStyle)GetAttributeObject(CommonCustomProperties.BackHatchStyle);
}
else
{
if(IsSerializing())
{
return ChartHatchStyle.None;
}
if(this.isEmptyPoint)
{
return (ChartHatchStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackHatchStyle);
}
return series.backHatchStyle;
}
}
else
{
return series.backHatchStyle;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.BackHatchStyle, value);
else
series.backHatchStyle = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the font of the data point.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeFont"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Font Font
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.Font))
{
Font font = GetAttributeObject(CommonCustomProperties.Font) as Font;
if (font != null)
return font;
}
if(IsSerializing())
{
return series.FontCache.DefaultFont;
}
if(this.isEmptyPoint)
{
return series.EmptyPointStyle.Font;
}
return series.font;
}
else
{
return series.font;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.Font, value);
else
series.font = value;
this.Invalidate(false);
}
}
/// <summary>
/// Gets or sets the label color.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeFontColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color LabelForeColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelForeColor))
{
Color color = (Color)GetAttributeObject(CommonCustomProperties.LabelForeColor);
return color;
}
else
{
if(IsSerializing())
{
return Color.Black;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelForeColor);
}
return series.fontColor;
}
}
else
{
return series.fontColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelForeColor, value);
else
series.fontColor = value;
this.Invalidate(false);
}
}
/// <summary>
/// Gets or sets the angle of the label.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription(SR.Keys.DescriptionAttributeLabel_FontAngle),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
]
public int LabelAngle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelAngle))
{
return (int)GetAttributeObject(CommonCustomProperties.LabelAngle);
}
else
{
if(IsSerializing())
{
return 0;
}
if(this.isEmptyPoint)
{
return (int)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelAngle);
}
return series.fontAngle;
}
}
else
{
return series.fontAngle;
}
}
set
{
if(value < -90 || value > 90)
{
throw (new ArgumentOutOfRangeException("value", SR.ExceptionAngleRangeInvalid));
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelAngle, value);
else
series.fontAngle = value;
this.Invalidate(false);
}
}
/// <summary>
/// Gets or sets the marker style.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerStyle4"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
Editor(Editors.MarkerStyleEditor.Editor, Editors.MarkerStyleEditor.Base),
RefreshProperties(RefreshProperties.All)
]
public MarkerStyle MarkerStyle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerStyle))
{
return (MarkerStyle)GetAttributeObject(CommonCustomProperties.MarkerStyle);
}
else
{
if(IsSerializing())
{
return MarkerStyle.None;
}
if(this.isEmptyPoint)
{
return (MarkerStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerStyle);
}
return series.markerStyle;
}
}
else
{
return series.markerStyle;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerStyle, value);
else
series.markerStyle = value;
Series thisSeries = this as Series;
if(thisSeries != null)
{
thisSeries.tempMarkerStyleIsSet = false;
}
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the size of the marker.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerSize"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
RefreshProperties(RefreshProperties.All)
]
public int MarkerSize
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerSize))
{
return (int)GetAttributeObject(CommonCustomProperties.MarkerSize);
}
else
{
if(IsSerializing())
{
return 5;
}
if(this.isEmptyPoint)
{
return (int)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerSize);
}
return series.markerSize;
}
}
else
{
return series.markerSize;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerSize, value);
else
series.markerSize = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the marker image.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerImage"),
Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
RefreshProperties(RefreshProperties.All)
]
public string MarkerImage
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerImage))
{
return (string)GetAttributeObject(CommonCustomProperties.MarkerImage);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerImage);
}
return series.markerImage;
}
}
else
{
return series.markerImage;
}
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerImage, value);
else
series.markerImage = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the color which will be replaced with a transparent color while drawing the marker image.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeImageTransparentColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
RefreshProperties(RefreshProperties.All)
]
public Color MarkerImageTransparentColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerImageTransparentColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor);
}
return series.markerImageTransparentColor;
}
}
else
{
return series.markerImageTransparentColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor, value);
else
series.markerImageTransparentColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the marker color.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerColor3"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
RefreshProperties(RefreshProperties.All)
]
public Color MarkerColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.MarkerColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerColor);
}
return series.markerColor;
}
}
else
{
return series.markerColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerColor, value);
else
series.markerColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the border color of the marker.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerBorderColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
RefreshProperties(RefreshProperties.All)
]
public Color MarkerBorderColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerBorderColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.MarkerBorderColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerBorderColor);
}
return series.markerBorderColor;
}
}
else
{
return series.markerBorderColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerBorderColor, value);
else
series.markerBorderColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the border width of the marker.
/// </summary>
[
SRCategory("CategoryAttributeMarker"),
Bindable(true),
SRDescription("DescriptionAttributeMarkerBorderWidth"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int MarkerBorderWidth
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MarkerBorderWidth))
{
return (int)GetAttributeObject(CommonCustomProperties.MarkerBorderWidth);
}
else
{
if(IsSerializing())
{
return 1;
}
if(this.isEmptyPoint)
{
return (int)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerBorderWidth);
}
return series.markerBorderWidth;
}
}
else
{
return series.markerBorderWidth;
}
}
set
{
if(value < 0)
{
throw (new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsNotPositive));
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MarkerBorderWidth, value);
else
series.markerBorderWidth = value;
this.Invalidate(true);
}
}
/// <summary>
/// Gets or sets the extended custom properties of the data point.
/// Extended custom properties can be specified in the following format:
/// AttrName1=Value1, AttrName2=Value2, ...
/// </summary>
[
SRCategory("CategoryAttributeMisc"),
Bindable(false),
SRDescription("DescriptionAttributeCustomAttributesExtended"),
DefaultValue(null),
RefreshProperties(RefreshProperties.All),
NotifyParentPropertyAttribute(true),
DesignOnlyAttribute(true),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SerializationVisibilityAttribute(SerializationVisibility.Hidden),
EditorBrowsableAttribute(EditorBrowsableState.Never),
DisplayName("CustomProperties")
]
public CustomProperties CustomPropertiesExtended
{
set
{
customProperties = value;
}
get
{
return customProperties;
}
}
/// <summary>
/// Gets or sets the custom properties of the data point.
/// Custom properties can be specified in the following format:
/// AttrName1=Value1, AttrName2=Value2, ...
/// </summary>
[
SRCategory("CategoryAttributeMisc"),
Bindable(true),
Browsable(false),
SRDescription("DescriptionAttributeCustomAttributesExtended"),
DefaultValue(""),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public string CustomProperties
{
get
{
// Save all custom properties in a string
string result = "";
string[] attributesNames = CommonCustomProperties.GetNames(typeof(CommonCustomProperties));
for(int i = properties.Count - 1; i >= 0; i--)
{
if(this[i] != null)
{
string attributeName = this[i];
// Check if attribute is custom
bool customAttribute = true;
foreach(string name in attributesNames)
{
if(String.Compare(attributeName, name, StringComparison.OrdinalIgnoreCase) == 0)
{
customAttribute = false;
break;
}
}
// Add custom attribute to the string
if(customAttribute && properties[attributeName] != null)
{
if(result.Length > 0)
{
result += ", ";
}
string attributeValue = properties[attributeName].ToString().Replace(",", "\\,");
attributeValue = attributeValue.Replace("=", "\\=");
result += attributeName + "=" + attributeValue;
}
}
}
return result;
}
set
{
// Replace NULL with empty string
if(value == null)
{
value = string.Empty;
}
// Copy all common properties to the new collection
Hashtable newAttributes = new Hashtable();
Array enumValues = Enum.GetValues(typeof(CommonCustomProperties));
foreach(object val in enumValues)
{
if(IsCustomPropertySet((CommonCustomProperties)val))
{
newAttributes[(int)val] = properties[(int)val];
}
}
if(value.Length > 0)
{
// Replace commas in value string
value = value.Replace("\\,", "\\x45");
value = value.Replace("\\=", "\\x46");
// Add new custom properties
string[] nameValueStrings = value.Split(',');
foreach(string nameValue in nameValueStrings)
{
string[] values = nameValue.Split('=');
// Check format
if(values.Length != 2)
{
throw(new FormatException( SR.ExceptionAttributeInvalidFormat));
}
// Check for empty name or value
values[0] = values[0].Trim();
values[1] = values[1].Trim();
if(values[0].Length == 0)
{
throw(new FormatException( SR.ExceptionAttributeInvalidFormat));
}
// Check if value already defined
foreach(object existingAttributeName in newAttributes.Keys)
{
string existingAttributeNameStr = existingAttributeName as string;
if (existingAttributeNameStr != null)
{
if (String.Compare(existingAttributeNameStr, values[0], StringComparison.OrdinalIgnoreCase) == 0)
{
throw(new FormatException( SR.ExceptionAttributeNameIsNotUnique(values[0] ) ) );
}
}
}
string newValue = values[1].Replace("\\x45", ",");
newAttributes[values[0]] = newValue.Replace("\\x46", "=");
}
}
properties = newAttributes;
this.Invalidate(true);
}
}
#endregion
#region IMapAreaAttributesutes Properties implementation
/// <summary>
/// Tooltip.
/// </summary>
[
SRCategory("CategoryAttributeMapArea"),
Bindable(true),
SRDescription("DescriptionAttributeToolTip"),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public string ToolTip
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.ToolTip, value);
else
series.toolTip = value;
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.ToolTip))
{
return (String)GetAttributeObject(CommonCustomProperties.ToolTip);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.ToolTip);
}
return series.toolTip;
}
}
else
{
return series.toolTip;
}
}
}
#if !Microsoft_CONTROL
/// <summary>
/// URL target of the area.
/// </summary>
[
SRCategory("CategoryAttributeMapArea"),
Bindable(true),
SRDescription("DescriptionAttributeUrl"),
DefaultValue(""),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base)
#endif
]
public string Url
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.Url, value);
else
series.url = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.Url))
{
return (String)GetAttributeObject(CommonCustomProperties.Url);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Url);
}
return series.url;
}
}
else
{
return series.url;
}
}
}
/// <summary>
/// Other attributes of the area.
/// </summary>
[
SRCategory("CategoryAttributeMapArea"),
Bindable(true),
SRDescription("DescriptionAttributeMapAreaAttributes"),
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base)
]
public string MapAreaAttributes
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.MapAreaAttributes, value);
else
series.mapAreaAttributes = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.MapAreaAttributes))
{
return (String)GetAttributeObject(CommonCustomProperties.MapAreaAttributes);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MapAreaAttributes);
}
return series.mapAreaAttributes;
}
}
else
{
return series.mapAreaAttributes;
}
}
}
/// <summary>
/// Gets or sets the postback value which can be processed on click event.
/// </summary>
/// <value>The value which is passed to click event as argument.</value>
[DefaultValue("")]
[SRCategory(SR.Keys.CategoryAttributeMapArea)]
[SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
[Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base)]
public string PostBackValue
{
get
{
if (this.pointCustomProperties)
{
if (properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.PostBackValue))
{
return (String)GetAttributeObject(CommonCustomProperties.PostBackValue);
}
else
{
if (IsSerializing())
{
return "";
}
if (this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.PostBackValue);
}
return series.postbackValue;
}
}
else
{
return series.postbackValue;
}
}
set
{
if (this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.PostBackValue, value);
else
series.postbackValue = value;
}
}
#endif
/// <summary>
/// Replaces predefined keyword inside the string with their values.
/// </summary>
/// <param name="strOriginal">Original string with keywords.</param>
/// <returns>Modified string.</returns>
internal virtual string ReplaceKeywords(string strOriginal)
{
return strOriginal;
}
#endregion
#region Legend properties
/// <summary>
/// Indicates whether the item is shown in the legend.
/// </summary>
[
SRCategory("CategoryAttributeLegend"),
Bindable(true),
SRDescription("DescriptionAttributeShowInLegend"),
#if !Microsoft_CONTROL
DefaultValue(true),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public bool IsVisibleInLegend
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.IsVisibleInLegend))
{
return (bool)GetAttributeObject(CommonCustomProperties.IsVisibleInLegend);
}
else
{
if(IsSerializing())
{
return true;
}
if(this.isEmptyPoint)
{
return (bool)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.IsVisibleInLegend);
}
return series.showInLegend;
}
}
else
{
return series.showInLegend;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.IsVisibleInLegend, value);
else
series.showInLegend = value;
this.Invalidate(true);
}
}
/// <summary>
/// Text of the item in the legend
/// </summary>
[
SRCategory("CategoryAttributeLegend"),
Bindable(true),
SRDescription("DescriptionAttributeLegendText"),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public string LegendText
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LegendText, value);
else
series.legendText = value;
this.Invalidate(true);
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LegendText))
{
return (String)GetAttributeObject(CommonCustomProperties.LegendText);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendText);
}
return series.legendText;
}
}
else
{
return series.legendText;
}
}
}
/// <summary>
/// Tooltip of the item in the legend
/// </summary>
[
SRCategory("CategoryAttributeLegend"),
Bindable(true),
SRDescription("DescriptionAttributeLegendToolTip"),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public string LegendToolTip
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LegendToolTip, value);
else
series.legendToolTip = value;
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LegendToolTip))
{
return (String)GetAttributeObject(CommonCustomProperties.LegendToolTip);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendToolTip);
}
return series.legendToolTip;
}
}
else
{
return series.legendToolTip;
}
}
}
/// <summary>
/// Background color of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeLabelBackColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
DefaultValue(typeof(Color), ""),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color LabelBackColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelBackColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.LabelBackColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBackColor);
}
return series.labelBackColor;
}
}
else
{
return series.labelBackColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelBackColor, value);
else
series.labelBackColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Border color of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBorderColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
DefaultValue(typeof(Color), ""),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color LabelBorderColor
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelBorderColor))
{
return (Color)GetAttributeObject(CommonCustomProperties.LabelBorderColor);
}
else
{
if(IsSerializing())
{
return Color.Empty;
}
if(this.isEmptyPoint)
{
return (Color)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderColor);
}
return series.labelBorderColor;
}
}
else
{
return series.labelBorderColor;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelBorderColor, value);
else
series.labelBorderColor = value;
this.Invalidate(true);
}
}
/// <summary>
/// Border style of the label.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeLabelBorderDashStyle"),
#if !Microsoft_CONTROL
DefaultValue(ChartDashStyle.Solid),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartDashStyle LabelBorderDashStyle
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelBorderDashStyle))
{
return (ChartDashStyle)GetAttributeObject(CommonCustomProperties.LabelBorderDashStyle);
}
else
{
if(IsSerializing())
{
return ChartDashStyle.Solid;
}
if(this.isEmptyPoint)
{
return (ChartDashStyle)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderDashStyle);
}
return series.labelBorderDashStyle;
}
}
else
{
return series.labelBorderDashStyle;
}
}
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelBorderDashStyle, value);
else
series.labelBorderDashStyle = value;
this.Invalidate(true);
}
}
/// <summary>
/// Border width of the label.
/// </summary>
[
SRCategory("CategoryAttributeLabelAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeBorderWidth"),
#if !Microsoft_CONTROL
DefaultValue(1),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int LabelBorderWidth
{
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelBorderWidth))
{
return (int)GetAttributeObject(CommonCustomProperties.LabelBorderWidth);
}
else
{
if(IsSerializing())
{
return 1;
}
if(this.isEmptyPoint)
{
return (int)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderWidth);
}
return series.labelBorderWidth;
}
}
else
{
return series.labelBorderWidth;
}
}
set
{
if(value < 0)
{
throw(new ArgumentOutOfRangeException("value", SR.ExceptionLabelBorderIsNotPositive));
}
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelBorderWidth, value);
else
series.labelBorderWidth = value;
this.Invalidate(true);
}
}
/// <summary>
/// Tooltip of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeLabel"),
Bindable(true),
SRDescription("DescriptionAttributeLabelToolTip"),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base),
#if !Microsoft_CONTROL
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public string LabelToolTip
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelToolTip, value);
else
series.labelToolTip = value;
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelToolTip))
{
return (String)GetAttributeObject(CommonCustomProperties.LabelToolTip);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelToolTip);
}
return series.labelToolTip;
}
}
else
{
return series.labelToolTip;
}
}
}
#if !Microsoft_CONTROL
/// <summary>
/// URL target of the item in the legend.
/// </summary>
[
SRCategory("CategoryAttributeLegend"),
Bindable(true),
SRDescription("DescriptionAttributeLegendUrl"),
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute),
Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base),
SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings")
]
public string LegendUrl
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LegendUrl, value);
else
series.legendUrl = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LegendUrl))
{
return (String)GetAttributeObject(CommonCustomProperties.LegendUrl);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendUrl);
}
return series.legendUrl;
}
}
else
{
return series.legendUrl;
}
}
}
#endif
#if !Microsoft_CONTROL
/// <summary>
/// Other attributes of the legend map area.
/// </summary>
[
SRCategory("CategoryAttributeLegend"),
Bindable(true),
SRDescription("DescriptionAttributeMapAreaAttributes"),
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute),
Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base)
]
public string LegendMapAreaAttributes
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes, value);
else
series.legendMapAreaAttributes = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LegendMapAreaAttributes))
{
return (String)GetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes);
}
return series.legendMapAreaAttributes;
}
}
else
{
return series.legendMapAreaAttributes;
}
}
}
/// <summary>
/// Gets or sets the postback value which can be processed on click event.
/// </summary>
/// <value>The value which is passed to click event as argument.</value>
[DefaultValue("")]
[SRCategory("CategoryAttributeLegend")]
[SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
[Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base)]
public string LegendPostBackValue
{
get
{
if (this.pointCustomProperties)
{
if (properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LegendPostBackValue))
{
return (String)GetAttributeObject(CommonCustomProperties.LegendPostBackValue);
}
else
{
if (IsSerializing())
{
return "";
}
if (this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendPostBackValue);
}
return series.legendPostbackValue;
}
}
else
{
return series.legendPostbackValue;
}
}
set
{
if (this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LegendPostBackValue, value);
else
series.legendPostbackValue = value;
}
}
#endif // !Microsoft_CONTROL
#if !Microsoft_CONTROL
/// <summary>
/// URL target of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeMapArea"),
Bindable(true),
SRDescription("DescriptionAttributeUrl"),
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute),
Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base),
SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings")
]
public string LabelUrl
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelUrl, value);
else
series.labelUrl = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelUrl))
{
return (String)GetAttributeObject(CommonCustomProperties.LabelUrl);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelUrl);
}
return series.labelUrl;
}
}
else
{
return series.labelUrl;
}
}
}
#endif //if !Microsoft_CONTROL
#if !Microsoft_CONTROL
/// <summary>
/// Other attributes of the data point label.
/// </summary>
[
SRCategory("CategoryAttributeLabel"),
Bindable(true),
SRDescription("DescriptionAttributeMapAreaAttributes"),
DefaultValue(""),
PersistenceMode(PersistenceMode.Attribute)
]
public string LabelMapAreaAttributes
{
set
{
if(this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes, value);
else
series.labelMapAreaAttributes = value;
}
get
{
if(this.pointCustomProperties)
{
if(properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelMapAreaAttributes))
{
return (String)GetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes);
}
else
{
if(IsSerializing())
{
return "";
}
if(this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes);
}
return series.labelMapAreaAttributes;
}
}
else
{
return series.labelMapAreaAttributes;
}
}
}
/// <summary>
/// Gets or sets the postback value which can be processed on click event.
/// </summary>
/// <value>The value which is passed to click event as argument.</value>
[DefaultValue("")]
[SRCategory("CategoryAttributeLabel")]
[SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
[Editor(Editors.KeywordsStringEditor.Editor, Editors.KeywordsStringEditor.Base)]
public string LabelPostBackValue
{
get
{
if (this.pointCustomProperties)
{
if (properties.Count != 0 && IsCustomPropertySet(CommonCustomProperties.LabelPostBackValue))
{
return (String)GetAttributeObject(CommonCustomProperties.LabelPostBackValue);
}
else
{
if (IsSerializing())
{
return "";
}
if (this.isEmptyPoint)
{
return (string)series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelPostBackValue);
}
return series.labelPostbackValue;
}
}
else
{
return series.labelPostbackValue;
}
}
set
{
if (this.pointCustomProperties)
SetAttributeObject(CommonCustomProperties.LabelPostBackValue, value);
else
series.labelPostbackValue = value;
}
}
#endif // !Microsoft_CONTROL
#endregion
#region Serialization control
private bool CheckIfSerializationRequired(CommonCustomProperties attribute)
{
if(this is DataPoint)
{
return IsCustomPropertySet(attribute);
}
else
{
object attr1 = this.GetAttributeObject(attribute);
object attr2 = Series.defaultCustomProperties.GetAttributeObject(attribute);
if(attr1 == null || attr2 == null)
{
return false;
}
return ! attr1.Equals(attr2);
}
}
private void ResetProperty(CommonCustomProperties attribute)
{
if(this is DataPoint)
{
DeleteCustomProperty(attribute);
}
else
{
this.SetAttributeObject(attribute, Series.defaultCustomProperties.GetAttributeObject(attribute));
}
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabel()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.Label);
else
return !String.IsNullOrEmpty(series.label);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeAxisLabel()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.AxisLabel);
else
return !String.IsNullOrEmpty(series.axisLabel);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelFormat()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelFormat);
else
return !String.IsNullOrEmpty(series.labelFormat);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeIsValueShownAsLabel()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.IsValueShownAsLabel);
else
return series.showLabelAsValue != false;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.Color);
else
return series.color != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBorderColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BorderColor);
else
return series.borderColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBorderDashStyle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BorderDashStyle);
else
return series.borderDashStyle != ChartDashStyle.Solid;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBorderWidth()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BorderWidth);
else
return series.borderWidth != 1;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerBorderWidth()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerBorderWidth);
else
return series.markerBorderWidth != 1;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackImage()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackImage);
else
return !String.IsNullOrEmpty(series.backImage);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackImageWrapMode()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackImageWrapMode);
else
return series.backImageWrapMode != ChartImageWrapMode.Tile;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackImageTransparentColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackImageTransparentColor);
else
return series.backImageTransparentColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackImageAlignment()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackImageAlignment);
else
return series.backImageAlignment != ChartImageAlignmentStyle.TopLeft;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackGradientStyle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackGradientStyle);
else
return series.backGradientStyle != GradientStyle.None;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackSecondaryColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackSecondaryColor);
else
return series.backSecondaryColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeBackHatchStyle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.BackHatchStyle);
else
return series.backHatchStyle != ChartHatchStyle.None;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeFont()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.Font);
else
{
return series.font != series.FontCache.DefaultFont;
}
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelForeColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelForeColor);
else
return series.fontColor != Color.Black;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelAngle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelAngle);
else
return series.fontAngle != 0f;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerStyle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerStyle);
else
return series.markerStyle != MarkerStyle.None;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerSize()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerSize);
else
return series.markerSize != 5;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerImage()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerImage);
else
return !String.IsNullOrEmpty(series.markerImage);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerImageTransparentColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerImageTransparentColor);
else
return series.markerImageTransparentColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerColor);
else
return series.markerColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMarkerBorderColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MarkerBorderColor);
else
return series.markerBorderColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeToolTip()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.ToolTip);
else
return !String.IsNullOrEmpty(series.toolTip);
}
#if !Microsoft_CONTROL
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeUrl()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.Url);
else
return !String.IsNullOrEmpty(series.url);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeMapAreaAttributes()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.MapAreaAttributes);
else
return !String.IsNullOrEmpty(series.mapAreaAttributes);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializePostBackValue()
{
if (this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.PostBackValue);
else
return !String.IsNullOrEmpty(series.postbackValue);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLegendUrl()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LegendUrl);
else
return !String.IsNullOrEmpty(series.legendUrl);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLegendMapAreaAttributes()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LegendMapAreaAttributes);
else
return !String.IsNullOrEmpty(series.legendMapAreaAttributes);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelUrl()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelUrl);
else
return !String.IsNullOrEmpty(series.labelUrl);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelMapAreaAttributes()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelMapAreaAttributes);
else
return !String.IsNullOrEmpty(series.labelMapAreaAttributes);
}
#endif // !Microsoft_CONTROL
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeIsVisibleInLegend()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.IsVisibleInLegend);
else
return series.showInLegend != true;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLegendText()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LegendText);
else
return !String.IsNullOrEmpty(series.legendText);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLegendToolTip()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LegendToolTip);
else
return !String.IsNullOrEmpty(series.legendToolTip);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelToolTip()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelToolTip);
else
return !String.IsNullOrEmpty(series.labelToolTip);
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelBackColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelBackColor);
else
return series.labelBackColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelBorderColor()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelBorderColor);
else
return series.labelBorderColor != Color.Empty;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelBorderDashStyle()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelBorderDashStyle);
else
return series.labelBorderDashStyle != ChartDashStyle.Solid;
}
/// <summary>
/// Returns true if property should be serialized.
/// </summary>
internal bool ShouldSerializeLabelBorderWidth()
{
if(this.pointCustomProperties)
return CheckIfSerializationRequired(CommonCustomProperties.LabelBorderWidth);
else
return series.labelBorderWidth != 1;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabel()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.Label);
else
series.label = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetAxisLabel()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.AxisLabel);
else
series.axisLabel = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelFormat()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelFormat);
else
series.labelFormat = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
public void ResetIsValueShownAsLabel()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.IsValueShownAsLabel);
else
series.IsValueShownAsLabel = false;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.Color);
else
series.color = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBorderColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BorderColor);
else
series.borderColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBorderDashStyle()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BorderDashStyle);
else
series.borderDashStyle = ChartDashStyle.Solid;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBorderWidth()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BorderWidth);
else
series.borderWidth = 1;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerBorderWidth()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerBorderWidth);
else
series.markerBorderWidth = 1;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBackImage()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BackImage);
else
series.backImage = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBackImageWrapMode()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BackImageWrapMode);
else
series.backImageWrapMode = ChartImageWrapMode.Tile;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBackImageTransparentColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BackImageTransparentColor);
else
series.backImageTransparentColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBackSecondaryColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BackSecondaryColor);
else
series.backSecondaryColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetBackHatchStyle()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.BackHatchStyle);
else
series.backHatchStyle = ChartHatchStyle.None;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetFont()
{
if (this.pointCustomProperties)
ResetProperty(CommonCustomProperties.Font);
else
{
series.font = series.FontCache.DefaultFont;
}
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelAngle()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelAngle);
else
series.fontAngle = 0;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerStyle()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerStyle);
else
series.markerStyle = MarkerStyle.None;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerSize()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerSize);
else
series.markerSize = 5;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerImage()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerImage);
else
series.markerImage = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerImageTransparentColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerImageTransparentColor);
else
series.markerImageTransparentColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerColor);
else
series.markerColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMarkerBorderColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MarkerBorderColor);
else
series.markerBorderColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetToolTip()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.ToolTip);
else
series.toolTip = "";
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
#if !Microsoft_CONTROL
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetUrl()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.Url);
else
series.url = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetMapAreaAttributes()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.MapAreaAttributes);
else
series.mapAreaAttributes = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetPostBackValue()
{
if (this.pointCustomProperties)
ResetProperty(CommonCustomProperties.PostBackValue);
else
series.postbackValue = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLegendUrl()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LegendUrl);
else
series.legendUrl = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLegendMapAreaAttributes()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LegendMapAreaAttributes);
else
series.legendMapAreaAttributes = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelUrl()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelUrl);
else
series.labelUrl = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelMapAreaAttributes()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelMapAreaAttributes);
else
series.labelMapAreaAttributes = "";
}
#endif // !Microsoft_CONTROL
/// <summary>
/// Resets property to its default value.
/// </summary>
public void ResetIsVisibleInLegend()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.IsVisibleInLegend);
else
series.showInLegend = true;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLegendText()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LegendText);
else
series.legendText = "";
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLegendToolTip()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LegendToolTip);
else
series.legendToolTip = "";
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelBackColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelBackColor);
else
series.labelBackColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelBorderColor()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelBorderColor);
else
series.labelBorderColor = Color.Empty;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelBorderDashStyle()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelBorderDashStyle);
else
series.labelBorderDashStyle = ChartDashStyle.Solid;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelBorderWidth()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelBorderWidth);
else
series.labelBorderWidth = 1;
}
/// <summary>
/// Resets property to its default value.
/// </summary>
internal void ResetLabelToolTip()
{
if(this.pointCustomProperties)
ResetProperty(CommonCustomProperties.LabelToolTip);
else
series.labelToolTip = "";
#if Microsoft_CONTROL
if(Chart != null && Chart.selection != null)
{
Chart.selection.enabledChecked = false;
}
#endif
}
#endregion
#region Invalidating method
/// <summary>
/// Invalidate chart area.
/// </summary>
/// <param name="invalidateLegend">Invalidate legend area only.</param>
[SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "This parameter is used when compiling for the Microsoft version of Chart")]
internal void Invalidate(bool invalidateLegend)
{
#if Microsoft_CONTROL
if(this.series != null)
{
series.Invalidate(true, invalidateLegend);
}
else
{
Series thisSeries = this as Series;
if (thisSeries != null)
{
thisSeries.Invalidate(true, invalidateLegend);
}
}
#endif
}
#endregion
}
/// <summary>
/// Class stores additional information about the data point in 3D space.
/// </summary>
internal class DataPoint3D
{
#region Fields
/// <summary>
/// Reference to the 2D data point object
/// </summary>
internal DataPoint dataPoint = null;
/// <summary>
/// Data point index.
/// </summary>
internal int index = 0;
/// <summary>
/// Point X position in relative coordinates.
/// </summary>
internal double xPosition = 0.0;
/// <summary>
/// Point Y position in relative coordinates.
/// </summary>
internal double yPosition = 0.0;
/// <summary>
/// Point X center position in relative coordinates. Used for side-by-side charts.
/// </summary>
internal double xCenterVal = 0.0;
/// <summary>
/// Point Z position in relative coordinates.
/// </summary>
internal float zPosition = 0f;
/// <summary>
/// Point width.
/// </summary>
internal double width = 0.0;
/// <summary>
/// Point height.
/// </summary>
internal double height = 0.0;
/// <summary>
/// Point depth.
/// </summary>
internal float depth = 0f;
/// <summary>
/// Indicates that point belongs to indexed series.
/// </summary>
internal bool indexedSeries = false;
#endregion
}
/// <summary>
/// Design-time representation of the CustomProperties.
/// This class is used instead of the string "CustomProperties"
/// property at design time and supports expandable list
/// of custom properties.
/// </summary>
[ TypeConverter(typeof(CustomPropertiesTypeConverter)) ]
[EditorBrowsable(EditorBrowsableState.Never)]
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
public class CustomProperties
{
#region Fields
// Reference to the properties class
internal DataPointCustomProperties m_DataPointCustomProperties = null;
#endregion // Fields
#region Constructor
/// <summary>
/// Constructor
/// </summary>
/// <param name="properties">Attributes object.</param>
internal CustomProperties(DataPointCustomProperties properties)
{
this.m_DataPointCustomProperties = properties;
}
#endregion // Constructor
#region Properties
internal virtual DataPointCustomProperties DataPointCustomProperties
{
get
{
return this.m_DataPointCustomProperties;
}
set
{
this.m_DataPointCustomProperties = value;
}
}
#endregion //Properties
#region Methods
/// <summary>
/// Gets a comma separated string of user defined custom properties.
/// </summary>
/// <returns>Comma separated string of user defined custom properties.</returns>
internal virtual string GetUserDefinedCustomProperties()
{
return GetUserDefinedCustomProperties(true);
}
/// <summary>
/// Gets a comma separated string of user defined or non-user defined custom properties.
/// </summary>
/// <param name="userDefined">True if user defined properties must be returned.</param>
/// <returns>Comma separated string of user defined custom properties.</returns>
internal virtual string GetUserDefinedCustomProperties(bool userDefined)
{
// Get comma separated string of custom properties
string customAttribute = this.DataPointCustomProperties.CustomProperties;
string userDefinedCustomAttribute = string.Empty;
// Get custom attribute registry
CustomPropertyRegistry registry = (CustomPropertyRegistry)this.DataPointCustomProperties.Common.container.GetService(typeof(CustomPropertyRegistry));
// Replace commas in value string
customAttribute = customAttribute.Replace("\\,", "\\x45");
customAttribute = customAttribute.Replace("\\=", "\\x46");
// Split custom properties by commas into individual properties
if(customAttribute.Length > 0)
{
string[] nameValueStrings = customAttribute.Split(',');
foreach(string nameValue in nameValueStrings)
{
string[] values = nameValue.Split('=');
// Check format
if(values.Length != 2)
{
throw(new FormatException(SR.ExceptionAttributeInvalidFormat));
}
// Check for empty name or value
values[0] = values[0].Trim();
values[1] = values[1].Trim();
if(values[0].Length == 0)
{
throw(new FormatException(SR.ExceptionAttributeInvalidFormat));
}
// Check if attribute is registered or user defined
bool userDefinedAttribute = true;
foreach(CustomPropertyInfo info in registry.registeredCustomProperties)
{
if(string.Compare(info.Name, values[0], StringComparison.OrdinalIgnoreCase) == 0)
{
userDefinedAttribute = false;
}
}
// Copy attribute into the output string
if(userDefinedAttribute == userDefined)
{
if(userDefinedCustomAttribute.Length > 0)
{
userDefinedCustomAttribute += ", ";
}
string val = values[1].Replace("\\x45", ",");
val = val.Replace("\\x46", "=");
userDefinedCustomAttribute += values[0] + "=" + val;
}
}
}
return userDefinedCustomAttribute;
}
/// <summary>
/// Sets user defined custom properties without cleaning registered properties.
/// </summary>
/// <param name="val">New user defined properties.</param>
internal virtual void SetUserDefinedAttributes(string val)
{
// Get non-user defined custom properties
string properties = GetUserDefinedCustomProperties(false);
// Check if new string is empty
if(val.Length > 0)
{
// Add comma at the end
if(properties.Length > 0)
{
properties += ", ";
}
// Add new user defined properties
properties += val;
}
// Set new custom attribute string
this.DataPointCustomProperties.CustomProperties = properties;
}
#endregion // Methods
}
}
Reference in New Issue View Git Blame Copy Permalink