|
//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
// Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
// File: Chart.cs
//
// Namespace: System.Web.UI.WebControls[Windows.Forms].Charting
//
// Classes: ChartImage, ChartPicture, ChartPaintEventArgs
//
// Purpose: This file contains classes, which are used for Image
// creation and chart painting. This file has also a
// class, which is used for Paint events arguments.
//
// Reviewed: GS - August 2, 2002
// AG - August 8, 2002
// AG - Microsoft 16, 2007
//
//===================================================================
#region Used Namespaces
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Design;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Resources;
using System.Reflection;
using System.IO;
using System.Data;
using System.Collections;
using System.Drawing.Imaging;
using System.Drawing.Text;
using System.Xml;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics;
using System.Security;
using System.Runtime.InteropServices;
using System.Collections.Generic;
#if Microsoft_CONTROL
using System.Windows.Forms.DataVisualization.Charting.Data;
using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
using System.Windows.Forms.DataVisualization.Charting.Utilities;
using System.Windows.Forms.DataVisualization.Charting.Borders3D;
using System.Windows.Forms.DataVisualization.Charting;
#else
using System.Web;
using System.Web.UI;
using System.Net;
using System.Web.UI.DataVisualization.Charting;
using System.Web.UI.DataVisualization.Charting.Data;
using System.Web.UI.DataVisualization.Charting.ChartTypes;
using System.Web.UI.DataVisualization.Charting.Utilities;
using System.Web.UI.DataVisualization.Charting.Borders3D;
#endif
#endregion
#if Microsoft_CONTROL
namespace System.Windows.Forms.DataVisualization.Charting
#else
namespace System.Web.UI.DataVisualization.Charting
#endif
{
#region Enumerations
#if !Microsoft_CONTROL
/// <summary>
/// An enumeration of supported image types
/// </summary>
public enum ChartImageType
{
/// <summary>
/// BMP image format
/// </summary>
Bmp,
/// <summary>
/// Jpeg image format
/// </summary>
Jpeg,
/// <summary>
/// Png image format
/// </summary>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Png")]
Png,
/// <summary>
/// Enhanced Meta File (Emf) image format.
/// </summary>
Emf,
};
#endif
#endregion
/// <summary>
/// ChartImage class adds image type and data binding functionality to
/// the base ChartPicture class.
/// </summary>
internal class ChartImage : ChartPicture
{
#region Fields
// Private data members, which store properties values
private int _compression = 0;
// Chart data source object
private object _dataSource = null;
// Indicates that control was bound to the data source
internal bool boundToDataSource = false;
#if !Microsoft_CONTROL
private ChartImageType imageType = ChartImageType.Png;
#endif
#endregion
#region Constructor
/// <summary>
/// Chart internal constructor.
/// </summary>
/// <param name="container">Service container</param>
internal ChartImage(IServiceContainer container)
: base(container)
{
}
#endregion // Constructor
#region Properties
/// <summary>
/// Gets or sets the data source for the Chart object.
/// </summary>
[
SRCategory("CategoryAttributeData"),
Bindable(true),
SRDescription("DescriptionAttributeDataSource"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SerializationVisibilityAttribute(SerializationVisibility.Hidden)
]
public object DataSource
{
get
{
return _dataSource;
}
set
{
if(_dataSource != value)
{
_dataSource = value;
this.boundToDataSource = false;
}
}
}
#if !Microsoft_CONTROL
/// <summary>
/// Image type (Jpeg, BMP, Png)
/// </summary>
[
SRCategory("CategoryAttributeImage"),
Bindable(true),
DefaultValue(ChartImageType.Png),
SRDescription("DescriptionAttributeImageType"),
PersistenceMode(PersistenceMode.Attribute)
]
public ChartImageType ImageType
{
get
{
return imageType;
}
set
{
imageType = value;
}
}
#endif
/// <summary>
/// Image compression value
/// </summary>
[
SRCategory("CategoryAttributeImage"),
Bindable(true),
DefaultValue(0),
SRDescription("DescriptionAttributeChartImage_Compression"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int Compression
{
get
{
return _compression;
}
set
{
if(value < 0 || value > 100)
{
throw (new ArgumentOutOfRangeException("value", SR.ExceptionChartCompressionInvalid));
}
_compression = value;
}
}
#endregion
#region Methods
#region Image Manipulation
/// <summary>
/// Saves image into the metafile stream.
/// </summary>
/// <param name="imageStream">Image stream.</param>
/// <param name="emfType">Image stream.</param>
[SecuritySafeCritical]
public void SaveIntoMetafile(Stream imageStream, EmfType emfType)
{
// Check arguments
if (imageStream == null)
throw new ArgumentNullException("imageStream");
// Create temporary Graphics object for metafile
using (Bitmap bitmap = new Bitmap(this.Width, this.Height))
{
using (Graphics newGraphics = Graphics.FromImage(bitmap))
{
IntPtr hdc = IntPtr.Zero;
try
{
System.Security.Permissions.SecurityPermission securityPermission = new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode);
securityPermission.Demand();
hdc = newGraphics.GetHdc();
// Create metafile object to record.
using (Metafile metaFile = new Metafile(
imageStream,
hdc,
new Rectangle(0, 0, this.Width, this.Height),
MetafileFrameUnit.Pixel,
emfType))
{
// Create graphics object to record metaFile.
using (Graphics metaGraphics = Graphics.FromImage(metaFile))
{
// Note: Fix for issue #3674. Some 3D borders shadows may be drawn outside
// of image boundaries. This causes issues when generated EMF file
// is placed in IE. Image looks shifted down and hot areas do not align.
if (this.BorderSkin.SkinStyle != BorderSkinStyle.None)
{
metaGraphics.Clip = new Region(new Rectangle(0, 0, this.Width, this.Height));
}
// Draw chart in the metafile
this.ChartGraph.IsMetafile = true;
this.Paint(metaGraphics, false);
this.ChartGraph.IsMetafile = false;
}
}
}
finally
{
if (hdc != IntPtr.Zero)
{
newGraphics.ReleaseHdc(hdc);
}
}
}
}
}
public Bitmap GetImage()
{
return this.GetImage(96);
}
/// <summary>
/// Create Image and draw chart picture
/// </summary>
public Bitmap GetImage(float resolution)
{
// Create a new bitmap
Bitmap image = null;
while (image == null)
{
bool failed = true;
try
{
image = new Bitmap(Math.Max(1,Width), Math.Max(1,Height));
image.SetResolution(resolution, resolution);
failed = false;
}
catch (ArgumentException)
{
failed = true;
}
catch (OverflowException)
{
failed = true;
}
catch (InvalidOperationException)
{
failed = true;
}
catch (ExternalException)
{
failed = true;
}
if (failed)
{
// if failed to create the image, decrease the size and the resolution of the chart
image = null;
float newResolution = Math.Max(resolution / 2, 96);
Width = (int)Math.Ceiling(Width * newResolution / resolution);
Height = (int)Math.Ceiling(Height * newResolution / resolution);
resolution = newResolution;
}
}
// Creates a new Graphics object from the
// specified Image object.
Graphics offScreen = Graphics.FromImage( image );
Color backGroundColor;
if (this.BackColor != Color.Empty)
backGroundColor = this.BackColor;
else
backGroundColor = Color.White;
// Get the page color if border skin is visible.
if (GetBorderSkinVisibility() &&
this.BorderSkin.PageColor != Color.Empty)
{
backGroundColor = this.BorderSkin.PageColor;
}
// draw a rctangle first with the size of the control, this prevent strange behavior when printing in the reporting services,
// without this rectangle, the printed picture is blurry
Pen pen = new Pen(backGroundColor);
offScreen.DrawRectangle(pen, 0, 0, Width, Height);
pen.Dispose();
// Paint the chart
Paint( offScreen , false);
// Dispose Graphic object
offScreen.Dispose();
// Return reference to the image
return image;
}
#endregion // Image Manipulation
#region Data Binding
/// <summary>
/// Checks if the type of the data source is valid.
/// </summary>
/// <param name="dataSource">Data source object to test.</param>
/// <returns>True if valid data source object.</returns>
static internal bool IsValidDataSource(object dataSource)
{
if( null != dataSource &&
(
dataSource is IEnumerable ||
dataSource is DataSet ||
dataSource is DataView ||
dataSource is DataTable ||
dataSource is System.Data.OleDb.OleDbCommand ||
dataSource is System.Data.SqlClient.SqlCommand ||
dataSource is System.Data.OleDb.OleDbDataAdapter ||
dataSource is System.Data.SqlClient.SqlDataAdapter ||
// ADDED: for VS2005 compatibility, DT Nov 25, 2005
dataSource.GetType().GetInterface("IDataSource") != null
// END ADDED
)
)
{
return true;
}
return false;
}
/// <summary>
/// Gets an list of the data source member names.
/// </summary>
/// <param name="dataSource">Data source object to get the members for.</param>
/// <param name="usedForYValue">Indicates that member will be used for Y values.</param>
/// <returns>List of member names.</returns>
[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily",
Justification = "Too large of a code change to justify making this change")]
static internal ArrayList GetDataSourceMemberNames(object dataSource, bool usedForYValue)
{
ArrayList names = new ArrayList();
if (dataSource != null)
{
// ADDED: for VS2005 compatibility, DT Nov 25, 2004
if (dataSource.GetType().GetInterface("IDataSource") != null)
{
try
{
MethodInfo m = dataSource.GetType().GetMethod("Select");
if (m != null)
{
if (m.GetParameters().Length == 1)
{
// SQL derived datasource
Type selectArgsType = dataSource.GetType().Assembly.GetType("System.Web.UI.DataSourceSelectArguments", true);
ConstructorInfo ci = selectArgsType.GetConstructor(new Type[] { });
dataSource = m.Invoke(dataSource, new object[] { ci.Invoke(new object[] { }) });
}
else
{
// object data source
dataSource = m.Invoke(dataSource, new object[] { });
}
}
}
catch (TargetException)
{
}
catch (TargetInvocationException)
{
}
}
// END ADDED
// Check all DataTable based data souces
DataTable dataTable = null;
if (dataSource is DataTable)
{
dataTable = (DataTable)dataSource;
}
else if (dataSource is DataView)
{
dataTable = ((DataView)dataSource).Table;
}
else if (dataSource is DataSet && ((DataSet)dataSource).Tables.Count > 0)
{
dataTable = ((DataSet)dataSource).Tables[0];
}
else if (dataSource is System.Data.OleDb.OleDbDataAdapter)
{
dataTable = new DataTable();
dataTable.Locale = CultureInfo.CurrentCulture;
dataTable = ((System.Data.OleDb.OleDbDataAdapter)dataSource).FillSchema(dataTable, SchemaType.Mapped);
}
else if (dataSource is System.Data.SqlClient.SqlDataAdapter)
{
dataTable = new DataTable();
dataTable.Locale = CultureInfo.CurrentCulture;
dataTable = ((System.Data.SqlClient.SqlDataAdapter)dataSource).FillSchema(dataTable, SchemaType.Mapped);
}
else if (dataSource is System.Data.OleDb.OleDbDataReader)
{
// Add table columns names
for (int fieldIndex = 0; fieldIndex < ((System.Data.OleDb.OleDbDataReader)dataSource).FieldCount; fieldIndex++)
{
if (!usedForYValue || ((System.Data.OleDb.OleDbDataReader)dataSource).GetFieldType(fieldIndex) != typeof(string))
{
names.Add(((System.Data.OleDb.OleDbDataReader)dataSource).GetName(fieldIndex));
}
}
}
else if (dataSource is System.Data.SqlClient.SqlDataReader)
{
// Add table columns names
for (int fieldIndex = 0; fieldIndex < ((System.Data.SqlClient.SqlDataReader)dataSource).FieldCount; fieldIndex++)
{
if (!usedForYValue || ((System.Data.SqlClient.SqlDataReader)dataSource).GetFieldType(fieldIndex) != typeof(string))
{
names.Add(((System.Data.SqlClient.SqlDataReader)dataSource).GetName(fieldIndex));
}
}
}
else if (dataSource is System.Data.OleDb.OleDbCommand)
{
System.Data.OleDb.OleDbCommand command = (System.Data.OleDb.OleDbCommand)dataSource;
if (command.Connection != null)
{
command.Connection.Open();
System.Data.OleDb.OleDbDataReader dataReader = command.ExecuteReader();
if (dataReader.Read())
{
for (int fieldIndex = 0; fieldIndex < dataReader.FieldCount; fieldIndex++)
{
if (!usedForYValue || dataReader.GetFieldType(fieldIndex) != typeof(string))
{
names.Add(dataReader.GetName(fieldIndex));
}
}
}
dataReader.Close();
command.Connection.Close();
}
}
else if (dataSource is System.Data.SqlClient.SqlCommand)
{
System.Data.SqlClient.SqlCommand command = (System.Data.SqlClient.SqlCommand)dataSource;
if (command.Connection != null)
{
command.Connection.Open();
System.Data.SqlClient.SqlDataReader dataReader = command.ExecuteReader();
if (dataReader.Read())
{
for (int fieldIndex = 0; fieldIndex < dataReader.FieldCount; fieldIndex++)
{
if (!usedForYValue || dataReader.GetFieldType(fieldIndex) != typeof(string))
{
names.Add(dataReader.GetName(fieldIndex));
}
}
}
dataReader.Close();
command.Connection.Close();
}
}
// Check if DataTable was set
if (dataTable != null)
{
// Add table columns names
foreach (DataColumn column in dataTable.Columns)
{
if (!usedForYValue || column.DataType != typeof(string))
{
names.Add(column.ColumnName);
}
}
}
else if (names.Count == 0 && dataSource is ITypedList)
{
foreach (PropertyDescriptor pd in ((ITypedList)dataSource).GetItemProperties(null))
{
if (!usedForYValue || pd.PropertyType != typeof(string))
{
names.Add(pd.Name);
}
}
}
else if (names.Count == 0 && dataSource is IEnumerable)
{
// .Net 2.0 ObjectDataSource processing
IEnumerator e = ((IEnumerable)dataSource).GetEnumerator();
e.Reset();
e.MoveNext();
foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(e.Current))
{
if (!usedForYValue || pd.PropertyType != typeof(string))
{
names.Add(pd.Name);
}
}
}
// Check if list still empty
if (names.Count == 0)
{
// Add first column or any data member name
names.Add("0");
}
}
return names;
}
/// <summary>
/// Data binds control to the data source
/// </summary>
[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily",
Justification="Too large of a code change to justify making this change")]
internal void DataBind()
{
// Set bound flag
this.boundToDataSource = true;
object dataSource = this.DataSource;
if (dataSource != null)
{
// Convert data adapters to command object
if (dataSource is System.Data.OleDb.OleDbDataAdapter)
{
dataSource = ((System.Data.OleDb.OleDbDataAdapter)dataSource).SelectCommand;
}
else if (dataSource is System.Data.SqlClient.SqlDataAdapter)
{
dataSource = ((System.Data.SqlClient.SqlDataAdapter)dataSource).SelectCommand;
}
// Convert data source to recognizable source for the series
if (dataSource is DataSet && ((DataSet)dataSource).Tables.Count > 0)
{
dataSource = ((DataSet)dataSource).DefaultViewManager.CreateDataView(((DataSet)dataSource).Tables[0]);
}
else if (dataSource is DataTable)
{
dataSource = new DataView((DataTable)dataSource);
}
else if (dataSource is System.Data.OleDb.OleDbCommand)
{
System.Data.OleDb.OleDbCommand command = (System.Data.OleDb.OleDbCommand)dataSource;
command.Connection.Open();
System.Data.OleDb.OleDbDataReader dataReader = command.ExecuteReader();
this.DataBind(dataReader, null);
dataReader.Close();
command.Connection.Close();
return;
}
else if (dataSource is System.Data.SqlClient.SqlCommand)
{
System.Data.SqlClient.SqlCommand command = (System.Data.SqlClient.SqlCommand)dataSource;
command.Connection.Open();
System.Data.SqlClient.SqlDataReader dataReader = command.ExecuteReader();
this.DataBind(dataReader, null);
dataReader.Close();
command.Connection.Close();
return;
}
else if (dataSource is IList)
{
dataSource = dataSource as IList;
}
else if (dataSource is IListSource )
{
if (((IListSource)dataSource).ContainsListCollection && ((IListSource)dataSource).GetList().Count > 0)
{
dataSource = ((IListSource)dataSource).GetList()[0] as IEnumerable;
}
else
{
dataSource = ((IListSource)dataSource).GetList();
}
}
else
{
dataSource = dataSource as IEnumerable;
}
// Data bind
DataBind(dataSource as IEnumerable, null);
}
}
/// <summary>
/// Data binds control to the data source
/// </summary>
/// <param name="dataSource">Data source to bind to.</param>
/// <param name="seriesList">List of series to bind.</param>
internal void DataBind(IEnumerable dataSource, ArrayList seriesList)
{
// Data bind series
if(dataSource != null && this.Common != null)
{
//************************************************************
//** If list of series is not provided - bind all of them.
//************************************************************
if(seriesList == null)
{
seriesList = new ArrayList();
foreach(Series series in this.Common.Chart.Series)
{
// note: added for design time data binding
if (this.Common.Chart.IsDesignMode())
{
if (series.YValueMembers.Length > 0)
{
seriesList.Add(series);
}
}
else
{
seriesList.Add(series);
}
}
}
//************************************************************
//** Clear all data points in data bound series
//************************************************************
foreach(Series series in seriesList)
{
if(series.XValueMember.Length > 0 || series.YValueMembers.Length > 0)
{
series.Points.Clear();
}
}
//************************************************************
//** Get and reset data enumerator.
//************************************************************
IEnumerator enumerator = dataSource.GetEnumerator();
if(enumerator.GetType() != typeof(System.Data.Common.DbEnumerator) )
{
try
{
enumerator.Reset();
}
// Some enumerators may not support Resetting
catch (InvalidOperationException)
{
}
catch (NotImplementedException)
{
}
catch (NotSupportedException)
{
}
}
//************************************************************
//** Loop through the enumerator.
//************************************************************
bool valueExsists = true;
bool autoDetectType = true;
do
{
// Move to the next item
valueExsists = enumerator.MoveNext();
// Loop through all series
foreach(Series series in seriesList)
{
if(series.XValueMember.Length > 0 || series.YValueMembers.Length > 0)
{
//************************************************************
//** Check and convert fields names.
//************************************************************
// Convert comma separated field names string to array of names
string[] yFieldNames = null;
if(series.YValueMembers.Length > 0)
{
yFieldNames = series.YValueMembers.Replace(",,", "\n").Split(',');
for(int index = 0; index < yFieldNames.Length; index++)
{
yFieldNames[index] = yFieldNames[index].Replace("\n", ",").Trim();
}
}
// Double check that a string object is not provided for data binding
if(dataSource is string)
{
throw (new ArgumentException(SR.ExceptionDataBindYValuesToString, "dataSource"));
}
// Check number of fields
if(yFieldNames == null || yFieldNames.GetLength(0) > series.YValuesPerPoint)
{
throw(new ArgumentOutOfRangeException("dataSource", SR.ExceptionDataPointYValuesCountMismatch(series.YValuesPerPoint.ToString(System.Globalization.CultureInfo.InvariantCulture) ) ) );
}
//************************************************************
//** Create new data point.
//************************************************************
if(valueExsists)
{
// Auto detect values type
if(autoDetectType)
{
autoDetectType = false;
// Make sure Y field is not empty
string yField = yFieldNames[0];
int fieldIndex = 1;
while(yField.Length == 0 && fieldIndex < yFieldNames.Length)
{
yField = yFieldNames[fieldIndex++];
}
DataPointCollection.AutoDetectValuesType(series, enumerator, series.XValueMember.Trim(), enumerator, yField);
}
// Create new point
DataPoint newDataPoint = new DataPoint(series);
bool emptyValues = false;
bool xValueIsNull = false;
//************************************************************
//** Get new point X and Y values.
//************************************************************
object[] yValuesObj = new object[yFieldNames.Length];
object xValueObj = null;
// Set X to the value provided or use sequence numbers starting with 1
if(series.XValueMember.Length > 0)
{
xValueObj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, series.XValueMember.Trim());
if(xValueObj is System.DBNull || xValueObj == null)
{
xValueIsNull = true;
emptyValues = true;
xValueObj = 0.0;
}
}
if(yFieldNames.Length == 0)
{
yValuesObj[0] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, null);
if(yValuesObj[0] is System.DBNull || yValuesObj[0] == null)
{
emptyValues = true;
yValuesObj[0] = 0.0;
}
}
else
{
for(int i = 0; i < yFieldNames.Length; i++)
{
if(yFieldNames[i].Length > 0)
{
yValuesObj[i] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, yFieldNames[i]);
if(yValuesObj[i] is System.DBNull || yValuesObj[i] == null)
{
emptyValues = true;
yValuesObj[i] = 0.0;
}
}
else
{
yValuesObj[i] = (((Series)seriesList[0]).IsYValueDateTime()) ? DateTime.Now.Date.ToOADate() : 0.0;
}
}
}
// Add data point if X value is not Null
if(!xValueIsNull)
{
if(emptyValues)
{
if(xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
series.Points.DataPointInit(ref newDataPoint);
newDataPoint.IsEmpty = true;
series.Points.Add(newDataPoint);
}
else
{
if(xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
series.Points.DataPointInit(ref newDataPoint);
series.Points.Add(newDataPoint);
}
}
if (this.Common.Chart.IsDesignMode())
{
series["TempDesignData"] = "true";
}
}
}
}
} while(valueExsists);
}
}
/// <summary>
/// Aligns data points using their axis labels.
/// </summary>
/// <param name="sortAxisLabels">Indicates if points should be sorted by axis labels.</param>
/// <param name="sortingOrder">Sorting pointSortOrder.</param>
internal void AlignDataPointsByAxisLabel(bool sortAxisLabels, PointSortOrder sortingOrder)
{
// Find series which are attached to the same X axis in the same chart area
foreach(ChartArea chartArea in this.ChartAreas)
{
// Check if chart area is visible
if(chartArea.Visible)
{
// Create series list for primary and secondary X axis
ArrayList chartAreaSeriesPrimary = new ArrayList();
ArrayList chartAreaSeriesSecondary = new ArrayList();
foreach(Series series in this.Common.Chart.Series)
{
// Check if series belongs to the chart area
if (series.ChartArea == chartArea.Name)
{
if(series.XSubAxisName.Length == 0)
{
if(series.XAxisType == AxisType.Primary)
{
chartAreaSeriesPrimary.Add(series);
}
else
{
chartAreaSeriesSecondary.Add(series);
}
}
}
}
// Align series
AlignDataPointsByAxisLabel(chartAreaSeriesPrimary, sortAxisLabels, sortingOrder);
AlignDataPointsByAxisLabel(chartAreaSeriesSecondary, sortAxisLabels, sortingOrder);
}
}
}
/// <summary>
/// Aligns data points using their axis labels.
/// </summary>
/// <param name="seriesList">List of series to align.</param>
/// <param name="sortAxisLabels">Indicates if points should be sorted by axis labels.</param>
/// <param name="sortingOrder">Sorting order.</param>
internal void AlignDataPointsByAxisLabel(
ArrayList seriesList,
bool sortAxisLabels,
PointSortOrder sortingOrder)
{
// List is empty
if(seriesList.Count == 0)
{
return;
}
// Collect information about all points in all series
bool indexedX = true;
bool uniqueAxisLabels = true;
ArrayList axisLabels = new ArrayList();
foreach(Series series in seriesList)
{
ArrayList seriesAxisLabels = new ArrayList();
foreach(DataPoint point in series.Points)
{
// Check if series has indexed X values
if(!series.IsXValueIndexed && point.XValue != 0.0)
{
indexedX = false;
break;
}
// Add axis label to the list and make sure it's non-empty and unique
if(point.AxisLabel.Length == 0)
{
uniqueAxisLabels = false;
break;
}
else if(seriesAxisLabels.Contains(point.AxisLabel))
{
uniqueAxisLabels = false;
break;
}
else if(!axisLabels.Contains(point.AxisLabel))
{
axisLabels.Add(point.AxisLabel);
}
seriesAxisLabels.Add(point.AxisLabel);
}
}
// Sort axis labels
if(sortAxisLabels)
{
axisLabels.Sort();
if(sortingOrder == PointSortOrder.Descending)
{
axisLabels.Reverse();
}
}
// All series must be indexed
if(!indexedX)
{
throw (new InvalidOperationException(SR.ExceptionChartDataPointsAlignmentFaild));
}
// AxisLabel can't be empty or duplicated
if(!uniqueAxisLabels)
{
throw (new InvalidOperationException(SR.ExceptionChartDataPointsAlignmentFaildAxisLabelsInvalid));
}
// Assign unique X values for data points in all series with same axis LabelStyle
if(indexedX && uniqueAxisLabels)
{
foreach(Series series in seriesList)
{
foreach(DataPoint point in series.Points)
{
point.XValue = axisLabels.IndexOf(point.AxisLabel) + 1;
}
// Sort points by X value
series.Sort(PointSortOrder.Ascending, "X");
}
// Make sure ther are no missing points
foreach(Series series in seriesList)
{
series.IsXValueIndexed = true;
for(int index = 0; index < axisLabels.Count; index++)
{
if(index >= series.Points.Count ||
series.Points[index].XValue != index + 1)
{
DataPoint newPoint = new DataPoint(series);
newPoint.AxisLabel = (string)axisLabels[index];
newPoint.XValue = index + 1;
newPoint.YValues[0] = 0.0;
newPoint.IsEmpty = true;
series.Points.Insert(index, newPoint);
}
}
}
}
}
/// <summary>
/// Data bind chart to the table. Series will be automatically added to the chart depending on
/// the number of unique values in the seriesGroupByField column of the data source.
/// Data source can be the Ole(SQL)DataReader, DataView, DataSet, DataTable or DataRow.
/// </summary>
/// <param name="dataSource">Data source.</param>
/// <param name="seriesGroupByField">Name of the field used to group data into series.</param>
/// <param name="xField">Name of the field for X values.</param>
/// <param name="yFields">Comma separated name(s) of the field(s) for Y value(s).</param>
/// <param name="otherFields">Other point properties binding rule in format: PointProperty=Field[{Format}] [,PointProperty=Field[{Format}]]. For example: "Tooltip=Price{C1},Url=WebSiteName".</param>
/// <param name="sort">Indicates that series should be sorted by group field.</param>
/// <param name="sortingOrder">Series sorting order by group field.</param>
internal void DataBindCrossTab(
IEnumerable dataSource,
string seriesGroupByField,
string xField,
string yFields,
string otherFields,
bool sort,
PointSortOrder sortingOrder)
{
// Check arguments
if (dataSource == null)
throw (new ArgumentNullException("dataSource", SR.ExceptionDataPointInsertionNoDataSource));
if (dataSource is string)
throw (new ArgumentException(SR.ExceptionDataBindSeriesToString, "dataSource"));
if (String.IsNullOrEmpty(yFields))
throw (new ArgumentException(SR.ExceptionChartDataPointsInsertionFailedYValuesEmpty, "yFields"));
if (String.IsNullOrEmpty(seriesGroupByField))
throw (new ArgumentException(SR.ExceptionDataBindSeriesGroupByParameterIsEmpty, "seriesGroupByField"));
// List of series and group by field values
ArrayList seriesList = new ArrayList();
ArrayList groupByValueList = new ArrayList();
// Convert comma separated Y values field names string to array of names
string[] yFieldNames = null;
if(yFields != null)
{
yFieldNames = yFields.Replace(",,", "\n").Split(',');
for(int index = 0; index < yFieldNames.Length; index++)
{
yFieldNames[index] = yFieldNames[index].Replace("\n", ",");
}
}
// Convert other fields/properties names to two arrays of names
string[] otherAttributeNames = null;
string[] otherFieldNames = null;
string[] otherValueFormat = null;
DataPointCollection.ParsePointFieldsParameter(
otherFields,
ref otherAttributeNames,
ref otherFieldNames,
ref otherValueFormat);
// Get and reset enumerator
IEnumerator enumerator = DataPointCollection.GetDataSourceEnumerator(dataSource);
if(enumerator.GetType() != typeof(System.Data.Common.DbEnumerator))
{
try
{
enumerator.Reset();
}
// Some enumerators may not support Resetting
catch (NotSupportedException)
{
}
catch (NotImplementedException)
{
}
catch (InvalidOperationException)
{
}
}
// Add data points
bool valueExsist = true;
object[] yValuesObj = new object[yFieldNames.Length];
object xValueObj = null;
bool autoDetectType = true;
do
{
// Move to the next objects in the enumerations
if(valueExsist)
{
valueExsist = enumerator.MoveNext();
}
// Create and initialize data point
if(valueExsist)
{
// Get value of the group by field
object groupObj = DataPointCollection.ConvertEnumerationItem(
enumerator.Current,
seriesGroupByField);
// Check series group by field and create new series if required
Series series = null;
int seriesIndex = groupByValueList.IndexOf(groupObj);
if(seriesIndex >= 0)
{
// Select existing series from the list
series = (Series)seriesList[seriesIndex];
}
else
{
// Create new series
series = new Series();
series.YValuesPerPoint = yFieldNames.GetLength(0);
// If not the first series in the list copy some properties
if(seriesList.Count > 0)
{
series.XValueType = ((Series)seriesList[0]).XValueType;
series.autoXValueType = ((Series)seriesList[0]).autoXValueType;
series.YValueType = ((Series)seriesList[0]).YValueType;
series.autoYValueType = ((Series)seriesList[0]).autoYValueType;
}
// Try to set series name based on grouping vlaue
string groupObjStr = groupObj as string;
if(groupObjStr != null)
{
series.Name = groupObjStr;
}
else
{
series.Name = seriesGroupByField + " - " + groupObj.ToString();
}
// Add series and group value into the lists
groupByValueList.Add(groupObj);
seriesList.Add(series);
}
// Auto detect valu(s) type
if(autoDetectType)
{
autoDetectType = false;
DataPointCollection.AutoDetectValuesType(series, enumerator, xField, enumerator, yFieldNames[0]);
}
// Create new data point
DataPoint newDataPoint = new DataPoint(series);
bool emptyValues = false;
// Set X to the value provided
if(xField.Length > 0)
{
xValueObj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, xField);
if( DataPointCollection.IsEmptyValue(xValueObj) )
{
emptyValues = true;
xValueObj = 0.0;
}
}
// Set Y values
if(yFieldNames.Length == 0)
{
yValuesObj[0] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, null);
if( DataPointCollection.IsEmptyValue(yValuesObj[0]) )
{
emptyValues = true;
yValuesObj[0] = 0.0;
}
}
else
{
for(int i = 0; i < yFieldNames.Length; i++)
{
yValuesObj[i] = DataPointCollection.ConvertEnumerationItem(enumerator.Current, yFieldNames[i]);
if( DataPointCollection.IsEmptyValue(yValuesObj[i] ) )
{
emptyValues = true;
yValuesObj[i] = 0.0;
}
}
}
// Set other values
if(otherAttributeNames != null &&
otherAttributeNames.Length > 0)
{
for(int i = 0; i < otherFieldNames.Length; i++)
{
// Get object by field name
object obj = DataPointCollection.ConvertEnumerationItem(enumerator.Current, otherFieldNames[i]);
if( !DataPointCollection.IsEmptyValue( obj ) )
{
newDataPoint.SetPointCustomProperty(
obj,
otherAttributeNames[i],
otherValueFormat[i]);
}
}
}
// IsEmpty value was detected
if(emptyValues)
{
if(xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointCollection.DataPointInit(series, ref newDataPoint);
newDataPoint.IsEmpty = true;
series.Points.Add(newDataPoint);
}
else
{
if(xValueObj != null)
{
newDataPoint.SetValueXY(xValueObj, yValuesObj);
}
else
{
newDataPoint.SetValueXY(0, yValuesObj);
}
DataPointCollection.DataPointInit(series, ref newDataPoint);
series.Points.Add(newDataPoint);
}
}
} while(valueExsist);
// Sort series usig values of group by field
if(sort)
{
// Duplicate current list
ArrayList oldList = (ArrayList)groupByValueList.Clone();
// Sort list
groupByValueList.Sort();
if(sortingOrder == PointSortOrder.Descending)
{
groupByValueList.Reverse();
}
// Change order of series in collection
ArrayList sortedSeriesList = new ArrayList();
foreach(object obj in groupByValueList)
{
sortedSeriesList.Add(seriesList[oldList.IndexOf(obj)]);
}
seriesList = sortedSeriesList;
}
// Add all series from the list into the series collection
foreach(Series series in seriesList)
{
this.Common.Chart.Series.Add(series);
}
}
/// <summary>
/// Automatically creates and binds series to specified data table.
/// Each column of the table becomes a Y value in a separate series.
/// Series X value field may also be provided.
/// </summary>
/// <param name="dataSource">Data source.</param>
/// <param name="xField">Name of the field for series X values.</param>
internal void DataBindTable(
IEnumerable dataSource,
string xField)
{
// Check arguments
if (dataSource == null)
throw new ArgumentNullException("dataSource");
// Get list of member names from the data source
ArrayList dataSourceFields = GetDataSourceMemberNames(dataSource, true);
// Remove X value field if it's there
if (xField != null && xField.Length > 0)
{
int index = -1;
for (int i = 0; i < dataSourceFields.Count; i++)
{
if ( String.Equals((string)dataSourceFields[i], xField, StringComparison.OrdinalIgnoreCase ) )
{
index = i;
break;
}
}
if (index >= 0)
{
dataSourceFields.RemoveAt(index);
}
else
{
// Check if field name passed as index
bool parseSucceed = int.TryParse(xField, NumberStyles.Any, CultureInfo.InvariantCulture, out index);
if (parseSucceed && index >= 0 && index < dataSourceFields.Count)
{
dataSourceFields.RemoveAt(index);
}
}
}
// Get number of series
int seriesNumber = dataSourceFields.Count;
if (seriesNumber > 0)
{
// Create as many series as fields in the data source
ArrayList seriesList = new ArrayList();
int index = 0;
foreach (string fieldName in dataSourceFields)
{
Series series = new Series(fieldName);
// Set binding properties
series.YValueMembers = fieldName;
series.XValueMember = xField;
// Add to list
seriesList.Add(series);
++index;
}
// Data bind series
this.DataBind(dataSource, seriesList);
// Add all series from the list into the series collection
foreach (Series series in seriesList)
{
// Clear binding properties
series.YValueMembers = String.Empty;
series.XValueMember = String.Empty;
// Add series into the list
this.Common.Chart.Series.Add(series);
}
}
}
#endregion // Data Binding
#endregion
}
/// <summary>
/// ChartPicture class represents chart content like legends, titles,
/// chart areas and series. It provides methods for positioning and
/// drawing all chart elements.
/// </summary>
internal class ChartPicture : ChartElement, IServiceProvider
{
#region Fields
/// <summary>
/// Indicates that chart exceptions should be suppressed.
/// </summary>
private bool _suppressExceptions = false;
// Chart Graphic object
internal ChartGraphics ChartGraph { get; set; }
// Private data members, which store properties values
private GradientStyle _backGradientStyle = GradientStyle.None;
private Color _backSecondaryColor = Color.Empty;
private Color _backColor = Color.White;
private string _backImage = "";
private ChartImageWrapMode _backImageWrapMode = ChartImageWrapMode.Tile;
private Color _backImageTransparentColor = Color.Empty;
private ChartImageAlignmentStyle _backImageAlign = ChartImageAlignmentStyle.TopLeft;
private Color _borderColor = Color.White;
private int _borderWidth = 1;
private ChartDashStyle _borderDashStyle = ChartDashStyle.NotSet;
private ChartHatchStyle _backHatchStyle = ChartHatchStyle.None;
private AntiAliasingStyles _antiAliasing = AntiAliasingStyles.All;
private TextAntiAliasingQuality _textAntiAliasingQuality = TextAntiAliasingQuality.High;
private bool _isSoftShadows = true;
private int _width = 300;
private int _height = 300;
private DataManipulator _dataManipulator = new DataManipulator();
internal HotRegionsList hotRegionsList = null;
private BorderSkin _borderSkin = null;
#if !Microsoft_CONTROL
private bool _isMapEnabled = true;
private MapAreasCollection _mapAreas = null;
#endif
// Chart areas collection
private ChartAreaCollection _chartAreas = null;
// Chart legend collection
private LegendCollection _legends = null;
// Chart title collection
private TitleCollection _titles = null;
// Chart annotation collection
private AnnotationCollection _annotations = null;
// Annotation smart labels class
internal AnnotationSmartLabel annotationSmartLabel = new AnnotationSmartLabel();
// Chart picture events
internal event EventHandler<ChartPaintEventArgs> BeforePaint;
internal event EventHandler<ChartPaintEventArgs> AfterPaint;
// Chart title position rectangle
private RectangleF _titlePosition = RectangleF.Empty;
// Element spacing size
internal const float elementSpacing = 3F;
// Maximum size of the font in percentage
internal const float maxTitleSize = 15F;
// Printing indicator
internal bool isPrinting = false;
// Indicates chart selection mode
internal bool isSelectionMode = false;
private FontCache _fontCache = new FontCache();
// Position of the chart 3D border
private RectangleF _chartBorderPosition = RectangleF.Empty;
#if Microsoft_CONTROL
// Saving As Image indicator
internal bool isSavingAsImage = false;
// Indicates that chart background is restored from the double buffer
// prior to drawing top level objects like annotations, cursors and selection.
internal bool backgroundRestored = false;
// Buffered image of non-top level chart elements
internal Bitmap nonTopLevelChartBuffer = null;
#endif // Microsoft_CONTROL
#endregion
#region Constructors
/// <summary>
/// Constructor.
/// </summary>
/// <param name="container">Service container</param>
public ChartPicture(IServiceContainer container)
{
if(container == null)
{
throw(new ArgumentNullException(SR.ExceptionInvalidServiceContainer));
}
// Create and set Common Elements
Common = new CommonElements(container);
ChartGraph= new ChartGraphics(Common);
hotRegionsList = new HotRegionsList(Common);
// Create border properties class
_borderSkin = new BorderSkin(this);
// Create a collection of chart areas
_chartAreas = new ChartAreaCollection(this);
// Create a collection of legends
_legends = new LegendCollection(this);
// Create a collection of titles
_titles = new TitleCollection(this);
// Create a collection of annotations
_annotations = new AnnotationCollection(this);
// Set Common elements for data manipulator
_dataManipulator.Common = Common;
#if !Microsoft_CONTROL
// Create map areas collection
_mapAreas = new MapAreasCollection();
#endif
}
/// <summary>
/// Returns Chart service object
/// </summary>
/// <param name="serviceType">Service AxisName</param>
/// <returns>Chart picture</returns>
[EditorBrowsableAttribute(EditorBrowsableState.Never)]
object IServiceProvider.GetService(Type serviceType)
{
if(serviceType == typeof(ChartPicture))
{
return this;
}
throw (new ArgumentException( SR.ExceptionChartPictureUnsupportedType( serviceType.ToString() ) ) );
}
#endregion
#region Painting and selection methods
/// <summary>
/// Performs empty painting.
/// </summary>
internal void PaintOffScreen()
{
// Check chart size
// NOTE: Fixes issue #4733
if (this.Width <= 0 || this.Height <= 0)
{
return;
}
// Set process Mode to hot regions
this.Common.HotRegionsList.ProcessChartMode |= ProcessMode.HotRegions;
#if Microsoft_CONTROL
this.Common.HotRegionsList.hitTestCalled = true;
#endif // Microsoft_CONTROL
// Enable selection mode
this.isSelectionMode = true;
// Hot Region list does not exist. Create the list.
//this.common.HotRegionsList.List = new ArrayList();
this.Common.HotRegionsList.Clear();
// Create a new bitmap
Bitmap image = new Bitmap(Math.Max(1,Width), Math.Max(1,Height));
// Creates a new Graphics object from the
// specified Image object.
Graphics offScreen = Graphics.FromImage(image);
// Connect Graphics object with Chart Graphics object
ChartGraph.Graphics = offScreen;
// Remember the previous dirty flag
#if Microsoft_CONTROL
bool oldDirtyFlag = this.Common.Chart.dirtyFlag;
#endif //Microsoft_CONTROL
Paint(ChartGraph.Graphics, false);
image.Dispose();
// Restore the previous dirty flag
#if Microsoft_CONTROL
this.Common.Chart.dirtyFlag = oldDirtyFlag;
#endif //Microsoft_CONTROL
// Disable selection mode
this.isSelectionMode = false;
// Set process Mode to hot regions
this.Common.HotRegionsList.ProcessChartMode |= ProcessMode.HotRegions;
}
/// <summary>
/// Gets text rendering quality.
/// </summary>
/// <returns>Text rendering quality.</returns>
internal TextRenderingHint GetTextRenderingHint()
{
TextRenderingHint result = TextRenderingHint.SingleBitPerPixelGridFit;
if( (this.AntiAliasing & AntiAliasingStyles.Text) == AntiAliasingStyles.Text )
{
result = TextRenderingHint.ClearTypeGridFit;
if(this.TextAntiAliasingQuality == TextAntiAliasingQuality.Normal)
{
result = TextRenderingHint.AntiAlias;
}
else if(this.TextAntiAliasingQuality == TextAntiAliasingQuality.SystemDefault)
{
result = TextRenderingHint.SystemDefault;
}
}
else
{
result = TextRenderingHint.SingleBitPerPixelGridFit;
}
return result;
}
internal bool GetBorderSkinVisibility()
{
return _borderSkin.SkinStyle != BorderSkinStyle.None && this.Width > 20 && this.Height > 20;
}
/// <summary>
/// This function paints a chart.
/// </summary>
/// <param name="graph">The graph provides drawing object to the display device. A Graphics object is associated with a specific device context.</param>
/// <param name="paintTopLevelElementOnly">Indicates that only chart top level elements like cursors, selection or annotation objects must be redrawn.</param>
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "3#svg")]
internal void Paint(
Graphics graph,
bool paintTopLevelElementOnly )
{
#if Microsoft_CONTROL
// Reset restored and saved backgound flags
this.backgroundRestored = false;
#endif // Microsoft_CONTROL
// Reset Annotation Smart Labels
this.annotationSmartLabel.Reset();
// Do not draw the control if size is less than 5 pixel
if (this.Width < 5 || this.Height < 5)
{
return;
}
#if Microsoft_CONTROL
bool resetHotRegionList = false;
if(
this.Common.HotRegionsList.hitTestCalled
|| IsToolTipsEnabled()
)
{
Common.HotRegionsList.ProcessChartMode = ProcessMode.HotRegions | ProcessMode.Paint;
this.Common.HotRegionsList.hitTestCalled = false;
// Clear list of hot regions
if(paintTopLevelElementOnly)
{
// If repainting only top level elements (annotations) -
// clear top level objects hot regions only
for(int index = 0; index < this.Common.HotRegionsList.List.Count; index++)
{
HotRegion region = (HotRegion)this.Common.HotRegionsList.List[index];
if(region.Type == ChartElementType.Annotation)
{
this.Common.HotRegionsList.List.RemoveAt(index);
--index;
}
}
}
else
{
// If repainting whole chart - clear all hot regions
resetHotRegionList = true;
}
}
else
{
Common.HotRegionsList.ProcessChartMode = ProcessMode.Paint;
// If repainting whole chart - clear all hot regions
resetHotRegionList = true;
}
// Reset hot region list
if(resetHotRegionList)
{
this.Common.HotRegionsList.Clear();
}
#else
if( this.IsMapEnabled )
{
Common.HotRegionsList.ProcessChartMode |= ProcessMode.ImageMaps | ProcessMode.Paint;
// Clear any existing non-custom image map areas
for(int index = 0; index < this.MapAreas.Count; index++)
{
MapArea mapArea = this.MapAreas[index];
if(!mapArea.IsCustom)
{
this.MapAreas.RemoveAt(index);
--index;
}
}
}
#endif //#if Microsoft_CONTROL
// Check if control was data bound
ChartImage chartImage = this as ChartImage;
if(chartImage != null && !chartImage.boundToDataSource)
{
if(this.Common != null && this.Common.Chart != null && !this.Common.Chart.IsDesignMode())
{
this.Common.Chart.DataBind();
}
}
// Connect Graphics object with Chart Graphics object
ChartGraph.Graphics = graph;
Common.graph = ChartGraph;
// Set anti alias mode
ChartGraph.AntiAliasing = _antiAliasing;
ChartGraph.softShadows = _isSoftShadows;
ChartGraph.TextRenderingHint = GetTextRenderingHint();
try
{
// Check if only chart area cursors and annotations must be redrawn
if(!paintTopLevelElementOnly)
{
// Fire Before Paint event
OnBeforePaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));
// Flag indicates that resize method should be called
// after adjusting the intervals in 3D charts
bool resizeAfterIntervalAdjusting = false;
// RecalculateAxesScale paint chart areas
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.Set3DAnglesAndReverseMode();
area.SetTempValues();
area.ReCalcInternal();
// Resize should be called the second time
if( area.Area3DStyle.Enable3D && !area.chartAreaIsCurcular)
{
resizeAfterIntervalAdjusting = true;
}
}
}
// Call Customize event
this.Common.Chart.CallOnCustomize();
// Resize picture
Resize(ChartGraph, resizeAfterIntervalAdjusting);
// This code is introduce because labels has to
// be changed when scene is rotated.
bool intervalReCalculated = false;
foreach (ChartArea area in _chartAreas )
{
if( area.Area3DStyle.Enable3D &&
!area.chartAreaIsCurcular
&& area.Visible
)
{
// Make correction for interval in 3D space
intervalReCalculated = true;
area.Estimate3DInterval( ChartGraph );
area.ReCalcInternal();
}
}
// Resize chart areas after updating 3D interval
if(resizeAfterIntervalAdjusting)
{
// NOTE: Fixes issue #6808.
// In 3D chart area interval will be changed to compenstae for the axis rotation angle.
// This will cause all standard labels to be changed. We need to call the customize event
// the second time to give user a chance to modify those labels.
if (intervalReCalculated)
{
// Call Customize event
this.Common.Chart.CallOnCustomize();
}
// Resize chart elements
Resize(ChartGraph);
}
//***********************************************************************
//** Draw chart 3D border
//***********************************************************************
if (GetBorderSkinVisibility())
{
// Fill rectangle with page color
ChartGraph.FillRectangleAbs( new RectangleF( 0, 0, Width-1 , Height-1 ),
_borderSkin.PageColor,
ChartHatchStyle.None,
"",
ChartImageWrapMode.Tile,
Color.Empty,
ChartImageAlignmentStyle.Center,
GradientStyle.None,
Color.Empty,
_borderSkin.PageColor,
1,
ChartDashStyle.Solid,
PenAlignment.Inset );
// Draw 3D border
ChartGraph.Draw3DBorderAbs(
_borderSkin,
this._chartBorderPosition,
BackColor,
BackHatchStyle,
BackImage,
BackImageWrapMode,
BackImageTransparentColor,
BackImageAlignment,
BackGradientStyle,
BackSecondaryColor,
BorderColor,
BorderWidth,
BorderDashStyle);
}
// Paint Background
else
{
ChartGraph.FillRectangleAbs( new RectangleF( 0, 0, Width-1 , Height-1 ),
BackColor,
BackHatchStyle,
BackImage,
BackImageWrapMode,
BackImageTransparentColor,
BackImageAlignment,
BackGradientStyle,
BackSecondaryColor,
BorderColor,
BorderWidth,
BorderDashStyle,
PenAlignment.Inset );
}
// Call BackPaint event
this.Chart.CallOnPrePaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));
// Call paint function for each chart area.
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.Paint(ChartGraph);
}
}
// This code is introduced because of GetPointsInterval method,
// which is very time consuming. There is no reason to calculate
// interval after painting.
foreach (ChartArea area in _chartAreas )
{
// Reset interval data
area.intervalData = double.NaN;
}
// Draw Legends
foreach(Legend legendCurrent in this.Legends)
{
legendCurrent.Paint(ChartGraph);
}
// Draw chart titles from the collection
foreach(Title titleCurrent in this.Titles)
{
titleCurrent.Paint(ChartGraph);
}
// Call Paint event
this.Chart.CallOnPostPaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));
}
// Draw annotation objects
this.Annotations.Paint(ChartGraph, paintTopLevelElementOnly);
// Draw chart areas cursors in all areas.
// Only if not in selection
if(!this.isSelectionMode)
{
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.PaintCursors(ChartGraph, paintTopLevelElementOnly);
}
}
}
// Return default values
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.Restore3DAnglesAndReverseMode();
area.GetTempValues();
}
}
}
catch(System.Exception)
{
throw;
}
finally
{
// Fire After Paint event
OnAfterPaint(new ChartPaintEventArgs(this.Chart, this.ChartGraph, this.Common, new ElementPosition(0, 0, 100, 100)));
// Restore temp values for each chart area
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.Restore3DAnglesAndReverseMode();
area.GetTempValues();
}
}
#if !Microsoft_CONTROL
if (this.Chart.IsDesignMode())
{
this.Chart.MapAreas.RemoveNonCustom();
}
#endif //!Microsoft_CONTROL
}
}
/// <summary>
/// Invoke before paint delegates.
/// </summary>
/// <param name="e">Event arguments.</param>
protected virtual void OnBeforePaint(ChartPaintEventArgs e)
{
if (BeforePaint != null)
{
//Invokes the delegates.
BeforePaint(this, e);
}
}
/// <summary>
/// Invoke after paint delegates.
/// </summary>
/// <param name="e">Event arguments.</param>
protected virtual void OnAfterPaint(ChartPaintEventArgs e)
{
if (AfterPaint != null)
{
//Invokes the delegates.
AfterPaint(this, e);
}
}
internal override void Invalidate()
{
base.Invalidate();
#if Microsoft_CONTROL
if (Chart!=null)
Chart.Invalidate();
#endif
}
#endregion
#region Resizing methods
/// <summary>
/// Resize the chart picture.
/// </summary>
/// <param name="chartGraph">Chart graphics.</param>
public void Resize(ChartGraphics chartGraph)
{
Resize(chartGraph, false);
}
/// <summary>
/// Resize the chart picture.
/// </summary>
/// <param name="chartGraph">Chart graphics.</param>
/// <param name="calcAreaPositionOnly">Indicates that only chart area position is calculated.</param>
public void Resize(ChartGraphics chartGraph, bool calcAreaPositionOnly)
{
// Set the chart size for Common elements
Common.Width = _width;
Common.Height = _height;
// Set the chart size for Chart graphics
chartGraph.SetPictureSize( _width, _height );
// Initialize chart area(s) rectangle
RectangleF chartAreasRectangle = new RectangleF(0, 0, _width - 1, _height - 1);
chartAreasRectangle = chartGraph.GetRelativeRectangle(chartAreasRectangle);
//******************************************************
//** Get the 3D border interface
//******************************************************
_titlePosition = RectangleF.Empty;
IBorderType border3D = null;
bool titleInBorder = false;
if(_borderSkin.SkinStyle != BorderSkinStyle.None)
{
// Set border size
this._chartBorderPosition = chartGraph.GetAbsoluteRectangle(chartAreasRectangle);
// Get border interface
border3D = Common.BorderTypeRegistry.GetBorderType(_borderSkin.SkinStyle.ToString());
if(border3D != null)
{
border3D.Resolution = chartGraph.Graphics.DpiX;
// Check if title should be displayed in the border
titleInBorder = border3D.GetTitlePositionInBorder() != RectangleF.Empty;
_titlePosition = chartGraph.GetRelativeRectangle(border3D.GetTitlePositionInBorder());
_titlePosition.Width = chartAreasRectangle.Width - _titlePosition.Width;
// Adjust are position to the border size
border3D.AdjustAreasPosition(chartGraph, ref chartAreasRectangle);
}
}
//******************************************************
//** Calculate position of all titles in the collection
//******************************************************
RectangleF frameTitlePosition = RectangleF.Empty;
if(titleInBorder)
{
frameTitlePosition = new RectangleF(_titlePosition.Location, _titlePosition.Size);
}
foreach(Title title in this.Titles)
{
if (title.DockedToChartArea == Constants.NotSetValue &&
title.Position.Auto &&
title.Visible)
{
title.CalcTitlePosition(chartGraph, ref chartAreasRectangle, ref frameTitlePosition, elementSpacing);
}
}
//******************************************************
//** Calculate position of all legends in the collection
//******************************************************
this.Legends.CalcLegendPosition(chartGraph, ref chartAreasRectangle, elementSpacing);
//******************************************************
//** Calculate position of the chart area(s)
//******************************************************
chartAreasRectangle.Width -= elementSpacing;
chartAreasRectangle.Height -= elementSpacing;
RectangleF areaPosition = new RectangleF();
// Get number of chart areas that requeres automatic positioning
int areaNumber = 0;
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
if(area.Position.Auto)
{
++areaNumber;
}
}
}
// Calculate how many columns & rows of areas we going to have
int areaColumns = (int)Math.Floor(Math.Sqrt(areaNumber));
if(areaColumns < 1)
{
areaColumns = 1;
}
int areaRows = (int)Math.Ceiling(((float)areaNumber) / ((float)areaColumns));
// Set position for all areas
int column = 0;
int row = 0;
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
if(area.Position.Auto)
{
// Calculate area position
areaPosition.Width = chartAreasRectangle.Width / areaColumns - elementSpacing;
areaPosition.Height = chartAreasRectangle.Height / areaRows - elementSpacing;
areaPosition.X = chartAreasRectangle.X + column * (chartAreasRectangle.Width / areaColumns) + elementSpacing;
areaPosition.Y = chartAreasRectangle.Y + row * (chartAreasRectangle.Height / areaRows) + elementSpacing;
// Calculate position of all titles in the collection docked outside of the chart area
TitleCollection.CalcOutsideTitlePosition(this, chartGraph, area, ref areaPosition, elementSpacing);
// Calculate position of the legend if it's docked outside of the chart area
this.Legends.CalcOutsideLegendPosition(chartGraph, area, ref areaPosition, elementSpacing);
// Set area position without changing the Auto flag
area.Position.SetPositionNoAuto(areaPosition.X, areaPosition.Y, areaPosition.Width, areaPosition.Height);
// Go to next area
++row;
if(row >= areaRows)
{
row = 0;
++column;
}
}
else
{
RectangleF rect = area.Position.ToRectangleF();
// Calculate position of all titles in the collection docked outside of the chart area
TitleCollection.CalcOutsideTitlePosition(this, chartGraph, area, ref rect, elementSpacing);
// Calculate position of the legend if it's docked outside of the chart area
this.Legends.CalcOutsideLegendPosition(chartGraph, area, ref rect, elementSpacing);
}
}
}
//******************************************************
//** Align chart areas Position if required
//******************************************************
AlignChartAreasPosition();
//********************************************************
//** Check if only chart area position must be calculated.
//********************************************************
if(!calcAreaPositionOnly)
{
//******************************************************
//** Call Resize function for each chart area.
//******************************************************
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.Resize(chartGraph);
}
}
//******************************************************
//** Align chart areas InnerPlotPosition if required
//******************************************************
AlignChartAreas(AreaAlignmentStyles.PlotPosition);
//******************************************************
//** Calculate position of the legend if it's inside
//** chart plotting area
//******************************************************
// Calculate position of all titles in the collection docked outside of the chart area
TitleCollection.CalcInsideTitlePosition(this, chartGraph, elementSpacing);
this.Legends.CalcInsideLegendPosition(chartGraph, elementSpacing);
}
}
/// <summary>
/// Minimum and maximum do not have to be calculated
/// from data series every time. It is very time
/// consuming. Minimum and maximum are buffered
/// and only when this flags are set Minimum and
/// Maximum are refreshed from data.
/// </summary>
internal void ResetMinMaxFromData()
{
if (_chartAreas != null)
{
// Call ResetMinMaxFromData function for each chart area.
foreach (ChartArea area in _chartAreas)
{
// Check if area is visible
if (area.Visible)
{
area.ResetMinMaxFromData();
}
}
}
}
/// <summary>
/// RecalculateAxesScale the chart picture.
/// </summary>
public void Recalculate()
{
// Call ReCalc function for each chart area.
foreach (ChartArea area in _chartAreas )
{
// Check if area is visible
if(area.Visible)
{
area.ReCalcInternal();
}
}
}
#endregion
#region Chart picture properties
// VSTS 96787-Text Direction (RTL/LTR)
#if !Microsoft_CONTROL
private RightToLeft rightToLeft = RightToLeft.No;
#endif //!Microsoft_CONTROL
/// <summary>
/// Gets or sets the RightToLeft type.
/// </summary>
[
DefaultValue(RightToLeft.No)
]
public RightToLeft RightToLeft
{
get
{
#if Microsoft_CONTROL
return this.Common.Chart.RightToLeft;
#else // !WIN_CONTROL
return this.rightToLeft;
#endif // WIN_CONTROL
}
set
{
#if Microsoft_CONTROL
this.Common.Chart.RightToLeft = value;
#else // !Microsoft_CONTROL
this.rightToLeft = value;
#endif // Microsoft_CONTROL
}
}
/// <summary>
/// Indicates that non-critical chart exceptions will be suppressed.
/// </summary>
[
SRCategory("CategoryAttributeMisc"),
DefaultValue(false),
SRDescription("DescriptionAttributeSuppressExceptions"),
]
internal bool SuppressExceptions
{
set
{
_suppressExceptions = value;
}
get
{
return _suppressExceptions;
}
}
/// <summary>
/// Chart border skin style.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(BorderSkinStyle.None),
SRDescription("DescriptionAttributeBorderSkin"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.InnerProperty),
#endif
]
public BorderSkin BorderSkin
{
get
{
return _borderSkin;
}
set
{
_borderSkin = value;
}
}
#if ! Microsoft_CONTROL
/// <summary>
/// Indicates that chart image map is enabled.
/// </summary>
[
SRCategory("CategoryAttributeMap"),
Bindable(true),
SRDescription("DescriptionAttributeMapEnabled"),
PersistenceMode(PersistenceMode.InnerProperty),
DefaultValue(true)
]
public bool IsMapEnabled
{
get
{
return _isMapEnabled;
}
set
{
_isMapEnabled = value;
}
}
/// <summary>
/// Chart map areas collection.
/// </summary>
[
SRCategory("CategoryAttributeMap"),
SRDescription("DescriptionAttributeMapAreas"),
PersistenceMode(PersistenceMode.InnerProperty),
Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
]
public MapAreasCollection MapAreas
{
get
{
return _mapAreas;
}
}
#endif
/// <summary>
/// Reference to chart area collection
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
SRDescription("DescriptionAttributeChartAreas"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.InnerProperty),
#endif
Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
]
public ChartAreaCollection ChartAreas
{
get
{
return _chartAreas;
}
}
/// <summary>
/// Chart legend collection.
/// </summary>
[
SRCategory("CategoryAttributeChart"),
SRDescription("DescriptionAttributeLegends"),
Editor(Editors.LegendCollectionEditor.Editor, Editors.LegendCollectionEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.InnerProperty),
#endif
]
public LegendCollection Legends
{
get
{
return _legends;
}
}
/// <summary>
/// Chart title collection.
/// </summary>
[
SRCategory("CategoryAttributeCharttitle"),
SRDescription("DescriptionAttributeTitles"),
Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.InnerProperty),
#endif
]
public TitleCollection Titles
{
get
{
return _titles;
}
}
/// <summary>
/// Chart annotation collection.
/// </summary>
[
SRCategory("CategoryAttributeChart"),
SRDescription("DescriptionAttributeAnnotations3"),
Editor(Editors.AnnotationCollectionEditor.Editor, Editors.AnnotationCollectionEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.InnerProperty),
#endif
]
public AnnotationCollection Annotations
{
get
{
return _annotations;
}
}
/// <summary>
/// Background color for the Chart
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(typeof(Color), "White"),
SRDescription("DescriptionAttributeBackColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BackColor
{
get
{
return _backColor;
}
set
{
#if !Microsoft_CONTROL
if(value == Color.Empty || value.A != 255 || value == Color.Transparent)
{
// NOTE: Transparent colors are valid
}
#endif
_backColor = value;
}
}
/// <summary>
/// Border color for the Chart
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(typeof(Color), "White"),
SRDescription("DescriptionAttributeBorderColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BorderColor
{
get
{
return _borderColor;
}
set
{
_borderColor = value;
}
}
/// <summary>
/// Chart width
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(300),
SRDescription("DescriptionAttributeWidth"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int Width
{
get
{
return _width;
}
set
{
this.InspectChartDimensions(value, this.Height);
_width = value;
Common.Width = _width;
}
}
/// <summary>
/// Series Data Manipulator
/// </summary>
[
SRCategory("CategoryAttributeData"),
SRDescription("DescriptionAttributeDataManipulator"),
Browsable(false),
DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
SerializationVisibilityAttribute(SerializationVisibility.Hidden)
]
public DataManipulator DataManipulator
{
get
{
return _dataManipulator;
}
}
/// <summary>
/// Chart height
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(300),
SRDescription("DescriptionAttributeHeight3"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int Height
{
get
{
return _height;
}
set
{
this.InspectChartDimensions(this.Width, value);
_height = value;
Common.Height = value;
}
}
/// <summary>
/// Back Hatch style
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(ChartHatchStyle.None),
SRDescription("DescriptionAttributeBackHatchStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
]
public ChartHatchStyle BackHatchStyle
{
get
{
return _backHatchStyle;
}
set
{
_backHatchStyle = value;
}
}
/// <summary>
/// Chart area background image
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(""),
SRDescription("DescriptionAttributeBackImage"),
Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
NotifyParentPropertyAttribute(true)
]
public string BackImage
{
get
{
return _backImage;
}
set
{
_backImage = value;
}
}
/// <summary>
/// Chart area background image drawing mode.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(ChartImageWrapMode.Tile),
NotifyParentPropertyAttribute(true),
SRDescription("DescriptionAttributeImageWrapMode"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartImageWrapMode BackImageWrapMode
{
get
{
return _backImageWrapMode;
}
set
{
_backImageWrapMode = value;
}
}
/// <summary>
/// Background image transparent color.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(typeof(Color), ""),
NotifyParentPropertyAttribute(true),
SRDescription("DescriptionAttributeImageTransparentColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BackImageTransparentColor
{
get
{
return _backImageTransparentColor;
}
set
{
_backImageTransparentColor = value;
}
}
/// <summary>
/// Background image alignment used by ClampUnscale drawing mode.
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(ChartImageAlignmentStyle.TopLeft),
NotifyParentPropertyAttribute(true),
SRDescription("DescriptionAttributeBackImageAlign"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartImageAlignmentStyle BackImageAlignment
{
get
{
return _backImageAlign;
}
set
{
_backImageAlign = value;
}
}
/// <summary>
/// Indicates that smoothing is applied while drawing shadows.
/// </summary>
[
SRCategory("CategoryAttributeImage"),
Bindable(true),
DefaultValue(true),
SRDescription("DescriptionAttributeSoftShadows3"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public bool IsSoftShadows
{
get
{
return _isSoftShadows;
}
set
{
_isSoftShadows = value;
}
}
/// <summary>
/// Specifies whether smoothing (antialiasing) is applied while drawing chart.
/// </summary>
[
SRCategory("CategoryAttributeImage"),
Bindable(true),
DefaultValue(typeof(AntiAliasingStyles), "All"),
SRDescription("DescriptionAttributeAntiAlias"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public AntiAliasingStyles AntiAliasing
{
get
{
return _antiAliasing;
}
set
{
_antiAliasing = value;
}
}
/// <summary>
/// Specifies the quality of text antialiasing.
/// </summary>
[
SRCategory("CategoryAttributeImage"),
Bindable(true),
DefaultValue(typeof(TextAntiAliasingQuality), "High"),
SRDescription("DescriptionAttributeTextAntiAliasingQuality"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public TextAntiAliasingQuality TextAntiAliasingQuality
{
get
{
return _textAntiAliasingQuality;
}
set
{
_textAntiAliasingQuality = value;
}
}
/// <summary>
/// A type for the background gradient
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(GradientStyle.None),
SRDescription("DescriptionAttributeBackGradientStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute),
#endif
Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
]
public GradientStyle BackGradientStyle
{
get
{
return _backGradientStyle;
}
set
{
_backGradientStyle = value;
}
}
/// <summary>
/// The second color which is used for a gradient
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(typeof(Color), ""),
SRDescription("DescriptionAttributeBackSecondaryColor"),
TypeConverter(typeof(ColorConverter)),
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public Color BackSecondaryColor
{
get
{
return _backSecondaryColor;
}
set
{
#if !Microsoft_CONTROL
if(value != Color.Empty && (value.A != 255 || value == Color.Transparent))
{
throw (new ArgumentException( SR.ExceptionBackSecondaryColorIsTransparent));
}
#endif
_backSecondaryColor = value;
}
}
/// <summary>
/// The width of the border line
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(1),
SRDescription("DescriptionAttributeChart_BorderlineWidth"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public int BorderWidth
{
get
{
return _borderWidth;
}
set
{
if(value < 0)
{
throw(new ArgumentOutOfRangeException("value", SR.ExceptionChartBorderIsNegative));
}
_borderWidth = value;
}
}
/// <summary>
/// The style of the border line
/// </summary>
[
SRCategory("CategoryAttributeAppearance"),
Bindable(true),
DefaultValue(ChartDashStyle.NotSet),
SRDescription("DescriptionAttributeBorderDashStyle"),
#if !Microsoft_CONTROL
PersistenceMode(PersistenceMode.Attribute)
#endif
]
public ChartDashStyle BorderDashStyle
{
get
{
return _borderDashStyle;
}
set
{
_borderDashStyle = value;
}
}
/// <summary>
/// Gets the font cache.
/// </summary>
/// <value>The font cache.</value>
internal FontCache FontCache
{
get { return _fontCache; }
}
#endregion
#region Chart areas alignment methods
/// <summary>
/// Checks if any of the chart areas are aligned.
/// Also checks if the chart ares name in AlignWithChartArea property is valid.
/// </summary>
/// <returns>True if at least one area requires alignment.</returns>
private bool IsAreasAlignmentRequired()
{
bool alignmentRequired = false;
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Check if area is aligned
if (area.AlignWithChartArea != Constants.NotSetValue)
{
alignmentRequired = true;
// Check the chart area used for alignment
if (this._chartAreas.IndexOf(area.AlignWithChartArea)<0)
{
throw (new InvalidOperationException(SR.ExceptionChartAreaNameReferenceInvalid(area.Name, area.AlignWithChartArea)));
}
}
}
}
return alignmentRequired;
}
/// <summary>
/// Creates a list of the aligned chart areas.
/// </summary>
/// <param name="masterArea">Master chart area.</param>
/// <param name="type">Alignment type.</param>
/// <param name="orientation">Vertical or Horizontal orientation.</param>
/// <returns>List of areas that area aligned to the master area.</returns>
private ArrayList GetAlignedAreasGroup(ChartArea masterArea, AreaAlignmentStyles type, AreaAlignmentOrientations orientation)
{
ArrayList areaList = new ArrayList();
// Loop throught the chart areas and get the ones aligned with specified master area
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
if(area.Name != masterArea.Name &&
area.AlignWithChartArea == masterArea.Name &&
(area.AlignmentStyle & type) == type &&
(area.AlignmentOrientation & orientation) == orientation )
{
// Add "slave" area into the list
areaList.Add(area);
}
}
}
// If list is not empty insert "master" area in the beginning
if(areaList.Count > 0)
{
areaList.Insert(0, masterArea);
}
return areaList;
}
/// <summary>
/// Performs specified type of alignment for the chart areas.
/// </summary>
/// <param name="type">Alignment type required.</param>
internal void AlignChartAreas(AreaAlignmentStyles type)
{
// Check if alignment required
if(IsAreasAlignmentRequired())
{
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Get vertical areas alignment group using current area as a master
ArrayList alignGroup = GetAlignedAreasGroup(
area,
type,
AreaAlignmentOrientations.Vertical);
// Align each area in the group
if(alignGroup.Count > 0)
{
AlignChartAreasPlotPosition(alignGroup, AreaAlignmentOrientations.Vertical);
}
// Get horizontal areas alignment group using current area as a master
alignGroup = GetAlignedAreasGroup(
area,
type,
AreaAlignmentOrientations.Horizontal);
// Align each area in the group
if(alignGroup.Count > 0)
{
AlignChartAreasPlotPosition(alignGroup, AreaAlignmentOrientations.Horizontal);
}
}
}
}
}
/// <summary>
/// Align inner plot position of the chart areas in the group.
/// </summary>
/// <param name="areasGroup">List of areas in the group.</param>
/// <param name="orientation">Group orientation.</param>
private void AlignChartAreasPlotPosition(ArrayList areasGroup, AreaAlignmentOrientations orientation)
{
//****************************************************************
//** Find the smalles size of the inner plot
//****************************************************************
RectangleF areaPlotPosition = ((ChartArea)areasGroup[0]).PlotAreaPosition.ToRectangleF();
foreach(ChartArea area in areasGroup)
{
if(area.PlotAreaPosition.X > areaPlotPosition.X)
{
areaPlotPosition.X += area.PlotAreaPosition.X - areaPlotPosition.X;
areaPlotPosition.Width -= area.PlotAreaPosition.X - areaPlotPosition.X;
}
if(area.PlotAreaPosition.Y > areaPlotPosition.Y)
{
areaPlotPosition.Y += area.PlotAreaPosition.Y - areaPlotPosition.Y;
areaPlotPosition.Height -= area.PlotAreaPosition.Y - areaPlotPosition.Y;
}
if(area.PlotAreaPosition.Right < areaPlotPosition.Right)
{
areaPlotPosition.Width -= areaPlotPosition.Right - area.PlotAreaPosition.Right;
if(areaPlotPosition.Width < 5)
{
areaPlotPosition.Width = 5;
}
}
if(area.PlotAreaPosition.Bottom < areaPlotPosition.Bottom)
{
areaPlotPosition.Height -= areaPlotPosition.Bottom - area.PlotAreaPosition.Bottom;
if(areaPlotPosition.Height < 5)
{
areaPlotPosition.Height = 5;
}
}
}
//****************************************************************
//** Align inner plot position for all areas
//****************************************************************
foreach(ChartArea area in areasGroup)
{
// Get curretn plot position of the area
RectangleF rect = area.PlotAreaPosition.ToRectangleF();
// Adjust area position
if( (orientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
{
rect.X = areaPlotPosition.X;
rect.Width = areaPlotPosition.Width;
}
if( (orientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
{
rect.Y = areaPlotPosition.Y;
rect.Height = areaPlotPosition.Height;
}
// Set new plot position in coordinates relative to chart picture
area.PlotAreaPosition.SetPositionNoAuto(rect.X, rect.Y, rect.Width, rect.Height);
// Set new plot position in coordinates relative to chart area position
rect.X = (rect.X - area.Position.X) / area.Position.Width * 100f;
rect.Y = (rect.Y - area.Position.Y) / area.Position.Height * 100f;
rect.Width = rect.Width / area.Position.Width * 100f;
rect.Height = rect.Height / area.Position.Height * 100f;
area.InnerPlotPosition.SetPositionNoAuto(rect.X, rect.Y, rect.Width, rect.Height);
if( (orientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
{
area.AxisX2.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
area.AxisX.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
}
if( (orientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
{
area.AxisY2.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
area.AxisY.AdjustLabelFontAtSecondPass(ChartGraph, area.InnerPlotPosition.Auto);
}
}
}
/// <summary>
/// Aligns positions of the chart areas.
/// </summary>
private void AlignChartAreasPosition()
{
// Check if alignment required
if(IsAreasAlignmentRequired())
{
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Check if area is alignd by Position to any other area
if (area.AlignWithChartArea != Constants.NotSetValue && (area.AlignmentStyle & AreaAlignmentStyles.Position) == AreaAlignmentStyles.Position)
{
// Get current area position
RectangleF areaPosition = area.Position.ToRectangleF();
// Get master chart area
ChartArea masterArea = this.ChartAreas[area.AlignWithChartArea];
// Vertical alignment
if((area.AlignmentOrientation & AreaAlignmentOrientations.Vertical) == AreaAlignmentOrientations.Vertical)
{
// Align area position
areaPosition.X = masterArea.Position.X;
areaPosition.Width = masterArea.Position.Width;
}
// Horizontal alignment
if((area.AlignmentOrientation & AreaAlignmentOrientations.Horizontal) == AreaAlignmentOrientations.Horizontal)
{
// Align area position
areaPosition.Y = masterArea.Position.Y;
areaPosition.Height = masterArea.Position.Height;
}
// Set new position
area.Position.SetPositionNoAuto(areaPosition.X, areaPosition.Y, areaPosition.Width, areaPosition.Height);
}
}
}
}
}
#if Microsoft_CONTROL
/// <summary>
/// Align chart areas cursor.
/// </summary>
/// <param name="changedArea">Changed chart area.</param>
/// <param name="orientation">Orientation of the changed cursor.</param>
/// <param name="selectionChanged">AxisName of change cursor or selection.</param>
internal void AlignChartAreasCursor(ChartArea changedArea, AreaAlignmentOrientations orientation, bool selectionChanged)
{
// Check if alignment required
if(IsAreasAlignmentRequired())
{
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Get vertical areas alignment group using current area as a master
ArrayList alignGroup = GetAlignedAreasGroup(
area,
AreaAlignmentStyles.Cursor,
orientation);
// Align each area in the group if it contains changed area
if(alignGroup.Contains(changedArea))
{
// Set cursor position for all areas in the group
foreach(ChartArea groupArea in alignGroup)
{
groupArea.alignmentInProcess = true;
if(orientation == AreaAlignmentOrientations.Vertical)
{
if(selectionChanged)
{
groupArea.CursorX.SelectionStart = changedArea.CursorX.SelectionStart;
groupArea.CursorX.SelectionEnd = changedArea.CursorX.SelectionEnd;
}
else
{
groupArea.CursorX.Position = changedArea.CursorX.Position;
}
}
if(orientation == AreaAlignmentOrientations.Horizontal)
{
if(selectionChanged)
{
groupArea.CursorY.SelectionStart = changedArea.CursorY.SelectionStart;
groupArea.CursorY.SelectionEnd = changedArea.CursorY.SelectionEnd;
}
else
{
groupArea.CursorY.Position = changedArea.CursorY.Position;
}
}
groupArea.alignmentInProcess = false;
}
}
}
}
}
}
/// <summary>
/// One of the chart areas was zoomed by the user.
/// </summary>
/// <param name="changedArea">Changed chart area.</param>
/// <param name="orientation">Orientation of the changed scaleView.</param>
/// <param name="disposeBufferBitmap">Area double fuffer image must be disposed.</param>
internal void AlignChartAreasZoomed(ChartArea changedArea, AreaAlignmentOrientations orientation, bool disposeBufferBitmap)
{
// Check if alignment required
if(IsAreasAlignmentRequired())
{
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Get vertical areas alignment group using current area as a master
ArrayList alignGroup = GetAlignedAreasGroup(
area,
AreaAlignmentStyles.AxesView,
orientation);
// Align each area in the group if it contains changed area
if(alignGroup.Contains(changedArea))
{
// Set cursor position for all areas in the group
foreach(ChartArea groupArea in alignGroup)
{
// Clear image buffer
if(groupArea.areaBufferBitmap != null && disposeBufferBitmap)
{
groupArea.areaBufferBitmap.Dispose();
groupArea.areaBufferBitmap = null;
}
if(orientation == AreaAlignmentOrientations.Vertical)
{
groupArea.CursorX.SelectionStart = double.NaN;
groupArea.CursorX.SelectionEnd = double.NaN;
}
if(orientation == AreaAlignmentOrientations.Horizontal)
{
groupArea.CursorY.SelectionStart = double.NaN;
groupArea.CursorY.SelectionEnd = double.NaN;
}
}
}
}
}
}
}
#endif //Microsoft_CONTROL
/// <summary>
/// Align chart areas axes views.
/// </summary>
/// <param name="changedArea">Changed chart area.</param>
/// <param name="orientation">Orientation of the changed scaleView.</param>
internal void AlignChartAreasAxesView(ChartArea changedArea, AreaAlignmentOrientations orientation)
{
// Check if alignment required
if(IsAreasAlignmentRequired())
{
// Loop through all chart areas
foreach(ChartArea area in this.ChartAreas)
{
// Check if chart area is visible
if(area.Visible)
{
// Get vertical areas alignment group using current area as a master
ArrayList alignGroup = GetAlignedAreasGroup(
area,
AreaAlignmentStyles.AxesView,
orientation);
// Align each area in the group if it contains changed area
if(alignGroup.Contains(changedArea))
{
// Set cursor position for all areas in the group
foreach(ChartArea groupArea in alignGroup)
{
groupArea.alignmentInProcess = true;
if(orientation == AreaAlignmentOrientations.Vertical)
{
groupArea.AxisX.ScaleView.Position = changedArea.AxisX.ScaleView.Position;
groupArea.AxisX.ScaleView.Size = changedArea.AxisX.ScaleView.Size;
groupArea.AxisX.ScaleView.SizeType = changedArea.AxisX.ScaleView.SizeType;
groupArea.AxisX2.ScaleView.Position = changedArea.AxisX2.ScaleView.Position;
groupArea.AxisX2.ScaleView.Size = changedArea.AxisX2.ScaleView.Size;
groupArea.AxisX2.ScaleView.SizeType = changedArea.AxisX2.ScaleView.SizeType;
}
if(orientation == AreaAlignmentOrientations.Horizontal)
{
groupArea.AxisY.ScaleView.Position = changedArea.AxisY.ScaleView.Position;
groupArea.AxisY.ScaleView.Size = changedArea.AxisY.ScaleView.Size;
groupArea.AxisY.ScaleView.SizeType = changedArea.AxisY.ScaleView.SizeType;
groupArea.AxisY2.ScaleView.Position = changedArea.AxisY2.ScaleView.Position;
groupArea.AxisY2.ScaleView.Size = changedArea.AxisY2.ScaleView.Size;
groupArea.AxisY2.ScaleView.SizeType = changedArea.AxisY2.ScaleView.SizeType;
}
groupArea.alignmentInProcess = false;
}
}
}
}
}
}
#endregion
#region Helper methods
/// <summary>
/// Inspects the chart dimensions.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
internal void InspectChartDimensions(int width, int height)
{
if (this.Chart.IsDesignMode() && ((width * height) > (100 * 1024 *1024)))
{
throw new ArgumentException(SR.ExceptionChartOutOfLimits);
}
if (width < 0)
{
throw new ArgumentException(SR.ExceptionValueMustBeGreaterThan("Width", "0px"));
}
if (height < 0)
{
throw new ArgumentException(SR.ExceptionValueMustBeGreaterThan("Height", "0px"));
}
}
/// <summary>
/// Loads chart appearance template from file.
/// </summary>
/// <param name="name">Template file name to load from.</param>
public void LoadTemplate(string name)
{
// Check arguments
if (name == null)
throw new ArgumentNullException("name");
// Load template data into the stream
#if Microsoft_CONTROL
Stream stream = new FileStream(name, FileMode.Open, FileAccess.Read);
#else // Microsoft_CONTROL
Stream stream = LoadTemplateData(name);
#endif // Microsoft_CONTROL
// Load template from stream
LoadTemplate(stream);
// Close tempate stream
stream.Close();
}
/// <summary>
/// Loads chart appearance template from stream.
/// </summary>
/// <param name="stream">Template stream to load from.</param>
public void LoadTemplate(Stream stream)
{
// Check arguments
if (stream == null)
throw new ArgumentNullException("stream");
ChartSerializer serializer = (ChartSerializer)this.Common.container.GetService(typeof(ChartSerializer));
if (serializer != null)
{
// Save previous serializer properties
string oldSerializableContent = serializer.SerializableContent;
string oldNonSerializableContent = serializer.NonSerializableContent;
SerializationFormat oldFormat = serializer.Format;
bool oldIgnoreUnknownXmlAttributes = serializer.IsUnknownAttributeIgnored;
bool oldTemplateMode = serializer.IsTemplateMode;
// Set serializer properties
serializer.Content = SerializationContents.Appearance;
serializer.SerializableContent += ",Chart.Titles,Chart.Annotations," +
"Chart.Legends,Legend.CellColumns,Legend.CustomItems,LegendItem.Cells," +
"Chart.Series,Series.*Style," +
"Chart.ChartAreas,ChartArea.Axis*," +
"Axis.*Grid,Axis.*TickMark, Axis.*Style," +
"Axis.StripLines, Axis.CustomLabels";
serializer.Format = SerializationFormat.Xml;
serializer.IsUnknownAttributeIgnored = true;
serializer.IsTemplateMode = true;
try
{
// Load template
serializer.Load(stream);
}
catch (Exception ex)
{
throw (new InvalidOperationException(ex.Message));
}
finally
{
// Restore previous serializer properties
serializer.SerializableContent = oldSerializableContent;
serializer.NonSerializableContent = oldNonSerializableContent;
serializer.Format = oldFormat;
serializer.IsUnknownAttributeIgnored = oldIgnoreUnknownXmlAttributes;
serializer.IsTemplateMode = oldTemplateMode;
}
}
}
#if !Microsoft_CONTROL
/// <summary>
/// Loads template data from the URL.
/// </summary>
/// <param name="url">Template URL.</param>
/// <returns>Stream with template data or null if error.</returns>
private Stream LoadTemplateData(string url)
{
Debug.Assert(url != null, "LoadTemplateData: handed a null url string");
Stream dataStream = null;
// Try to load as relative URL using the Control object
if(dataStream == null)
{
if (this.Common != null &&
this.Common.Chart != null &&
this.Common.Chart.Page != null)
{
try
{
dataStream = new FileStream(
this.Common.Chart.Page.MapPath(url),
FileMode.Open);
}
catch (NotSupportedException)
{
dataStream = null;
}
catch (SecurityException)
{
dataStream = null;
}
catch (FileNotFoundException)
{
dataStream = null;
}
catch (DirectoryNotFoundException)
{
dataStream = null;
}
catch (PathTooLongException)
{
dataStream = null;
}
}
}
// Try to load image using the Web Request
if(dataStream == null)
{
Uri templateUri = null;
try
{
// Try to create URI directly from template URL (will work in case of absolute URL)
templateUri = new Uri(url);
}
catch (UriFormatException)
{
templateUri = null;
}
// Make absolute URL using web form document URL
if(templateUri == null)
{
if (this.Common != null && this.Common.Chart != null)
{
string webFormUrl = this.Common.Chart.webFormDocumentURL;
int slashIndex = webFormUrl.LastIndexOf('/');
if(slashIndex != -1)
{
webFormUrl = webFormUrl.Substring(0, slashIndex + 1);
}
try
{
templateUri = new Uri(new Uri(webFormUrl), url);
}
catch (UriFormatException)
{
templateUri = null;
}
}
}
// Load image from file or web resource
if(templateUri != null)
{
try
{
WebRequest request = WebRequest.Create(templateUri);
dataStream = request.GetResponse().GetResponseStream();
}
catch (NotSupportedException)
{
dataStream = null;
}
catch (NotImplementedException)
{
dataStream = null;
}
catch (SecurityException)
{
dataStream = null;
}
}
}
// Try to load as file
if(dataStream == null)
{
dataStream = new FileStream(url, FileMode.Open);
}
return dataStream;
}
#endif // Microsoft_CONTROL
#if !Microsoft_CONTROL
/// <summary>
/// Writes chart map tag into the stream.
/// </summary>
/// <param name="output">Html writer to output the data to.</param>
/// <param name="mapName">Chart map name.</param>
internal void WriteChartMapTag(HtmlTextWriter output, string mapName)
{
output.WriteLine();
output.AddAttribute(HtmlTextWriterAttribute.Name, mapName);
output.AddAttribute(HtmlTextWriterAttribute.Id, mapName);
output.RenderBeginTag(HtmlTextWriterTag.Map);
//****************************************************
//** Fire map areas customize event
//****************************************************
// Make sure only non-custom items are passed into the event handler
MapAreasCollection custCollection = new MapAreasCollection();
// Move all non-custom items
for (int index = 0; index < _mapAreas.Count; index++)
{
if (!_mapAreas[index].IsCustom)
{
custCollection.Add(_mapAreas[index]);
_mapAreas.RemoveAt(index);
--index;
}
}
// Call a notification event, so that area items collection can be modified by user
Common.Chart.CallOnCustomizeMapAreas(custCollection);
// Add customized items
foreach(MapArea area in custCollection)
{
area.IsCustom = false;
_mapAreas.Add(area);
}
//****************************************************
//** Add all map areas
//****************************************************
foreach (MapArea area in _mapAreas)
{
area.RenderTag(output, this.Common.Chart);
}
// if this procedure is enforced to run the image maps have to have at least one map area.
if (_mapAreas.Count == 0)
{
output.Write("<area shape=\"rect\" coords=\"0,0,0,0\" alt=\"\" />");
}
//****************************************************
//** End of the map
//****************************************************
output.RenderEndTag();
return;
}
#endif
/// <summary>
/// Returns the default title from Titles collection.
/// </summary>
/// <param name="create">Create title if it doesn't exists.</param>
/// <returns>Default title.</returns>
internal Title GetDefaultTitle(bool create)
{
// Check if default title exists
Title defaultTitle = null;
foreach(Title title in this.Titles)
{
if(title.Name == "Default Title")
{
defaultTitle = title;
}
}
// Create new default title
if(defaultTitle == null && create)
{
defaultTitle = new Title();
defaultTitle.Name = "Default Title";
this.Titles.Insert(0, defaultTitle);
}
return defaultTitle;
}
/// <summary>
/// Checks if tooltips are enabled
/// </summary>
/// <returns>true if tooltips enabled</returns>
private bool IsToolTipsEnabled()
{
// Data series loop
foreach( Series series in Common.DataManager.Series )
{
// Check series tooltips
if( series.ToolTip.Length > 0)
{
// ToolTips enabled
return true;
}
// Check series tooltips
if( series.LegendToolTip.Length > 0 ||
series.LabelToolTip.Length > 0)
{
// ToolTips enabled
return true;
}
// Check point tooltips only for "non-Fast" chart types
if( !series.IsFastChartType() )
{
// Data point loop
foreach( DataPoint point in series.Points )
{
// ToolTip empty
if( point.ToolTip.Length > 0)
{
// ToolTips enabled
return true;
}
// ToolTip empty
if( point.LegendToolTip.Length > 0 ||
point.LabelToolTip.Length > 0)
{
// ToolTips enabled
return true;
}
}
}
}
// Legend items loop
foreach( Legend legend in Legends )
{
foreach( LegendItem legendItem in legend.CustomItems )
{
// ToolTip empty
if( legendItem.ToolTip.Length > 0 )
{
return true;
}
}
}
// Title items loop
foreach( Title title in Titles )
{
// ToolTip empty
if( title.ToolTip.Length > 0 )
{
return true;
}
}
return false;
}
#endregion
#region IDisposable Members
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Dispose managed resources
if (ChartGraph != null)
{
ChartGraph.Dispose();
ChartGraph = null;
}
if (_legends != null)
{
_legends.Dispose();
_legends = null;
}
if (_titles != null)
{
_titles.Dispose();
_titles = null;
}
if (_chartAreas != null)
{
_chartAreas.Dispose();
_chartAreas = null;
}
if (_annotations != null)
{
_annotations.Dispose();
_annotations = null;
}
if (hotRegionsList != null)
{
hotRegionsList.Dispose();
hotRegionsList = null;
}
if (_fontCache != null)
{
_fontCache.Dispose();
_fontCache = null;
}
if (_borderSkin != null)
{
_borderSkin.Dispose();
_borderSkin = null;
}
#if ! Microsoft_CONTROL
if (_mapAreas != null)
{
_mapAreas.Dispose();
_mapAreas = null;
}
#endif
#if Microsoft_CONTROL
if (nonTopLevelChartBuffer != null)
{
nonTopLevelChartBuffer.Dispose();
nonTopLevelChartBuffer = null;
}
#endif
}
base.Dispose(disposing);
}
#endregion
}
/// <summary>
/// Event arguments of Chart paint event.
/// </summary>
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
public class ChartPaintEventArgs : EventArgs
{
#region Fields
// Private fields
private object _chartElement = null;
private ChartGraphics _chartGraph = null;
private CommonElements _common = null;
private Chart _chart = null;
private ElementPosition _position = null;
#endregion
#region Properties
/// <summary>
/// Gets the chart element of the event.
/// </summary>
/// <value>The chart element.</value>
public object ChartElement
{
get
{
return _chartElement;
}
}
/// <summary>
/// Gets the ChartGraphics object of the event.
/// </summary>
public ChartGraphics ChartGraphics
{
get
{
return _chartGraph;
}
}
/// <summary>
/// Chart Common elements.
/// </summary>
internal CommonElements CommonElements
{
get
{
return _common;
}
}
/// <summary>
/// Chart element position in relative coordinates of the event.
/// </summary>
public ElementPosition Position
{
get
{
return _position;
}
}
/// <summary>
/// Chart object of the event.
/// </summary>
public Chart Chart
{
get
{
if (_chart == null && _common != null)
{
_chart = _common.Chart;
}
return _chart;
}
}
#endregion
#region Methods
/// <summary>
/// Default constructor is not accessible
/// </summary>
private ChartPaintEventArgs()
{
}
/// <summary>
/// Paint event arguments constructor.
/// </summary>
/// <param name="chartElement">Chart element.</param>
/// <param name="chartGraph">Chart graphics.</param>
/// <param name="common">Common elements.</param>
/// <param name="position">Position.</param>
internal ChartPaintEventArgs(object chartElement, ChartGraphics chartGraph, CommonElements common, ElementPosition position)
{
this._chartElement = chartElement;
this._chartGraph = chartGraph;
this._common = common;
this._position = position;
}
#endregion
}
/// <summary>
/// Event arguments of localized numbers formatting event.
/// </summary>
#if ASPPERM_35
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
#endif
public class FormatNumberEventArgs : EventArgs
{
#region Fields
// Private fields
private double _value;
private string _format;
private string _localizedValue;
private ChartValueType _valueType = ChartValueType.Auto;
private object _senderTag;
private ChartElementType _elementType = ChartElementType.Nothing;
#endregion
#region Properties
/// <summary>
/// Value to be formatted.
/// </summary>
public double Value
{
get { return this._value; }
}
/// <summary>
/// Localized text.
/// </summary>
public string LocalizedValue
{
get { return _localizedValue; }
set { _localizedValue = value; }
}
/// <summary>
/// Format string.
/// </summary>
public string Format
{
get { return _format; }
}
/// <summary>
/// Value type.
/// </summary>
public ChartValueType ValueType
{
get { return _valueType; }
}
/// <summary>
/// The sender object of the event.
/// </summary>
public object SenderTag
{
get { return _senderTag; }
}
/// <summary>
/// Chart element type.
/// </summary>
public ChartElementType ElementType
{
get { return _elementType; }
}
#endregion
#region Methods
/// <summary>
/// Default constructor is not accessible
/// </summary>
private FormatNumberEventArgs()
{
}
/// <summary>
/// Object constructor.
/// </summary>
/// <param name="value">Value to be formatted.</param>
/// <param name="format">Format string.</param>
/// <param name="valueType">Value type..</param>
/// <param name="localizedValue">Localized value.</param>
/// <param name="senderTag">Chart element object tag.</param>
/// <param name="elementType">Chart element type.</param>
internal FormatNumberEventArgs(double value, string format, ChartValueType valueType, string localizedValue, object senderTag, ChartElementType elementType)
{
this._value = value;
this._format = format;
this._valueType = valueType;
this._localizedValue = localizedValue;
this._senderTag = senderTag;
this._elementType = elementType;
}
#endregion
}
#region FontCache
/// <summary>
/// Font cache class helps ChartElements to reuse the Font instances
/// </summary>
internal class FontCache : IDisposable
{
#region Static
// Default font family name
private static string _defaultFamilyName;
/// <summary>
/// Gets the default font family name.
/// </summary>
/// <value>The default font family name.</value>
public static string DefaultFamilyName
{
get
{
if (_defaultFamilyName == null)
{
// Find the "Microsoft Sans Serif" font
foreach (FontFamily fontFamily in FontFamily.Families)
{
if (fontFamily.Name == "Microsoft Sans Serif")
{
_defaultFamilyName = fontFamily.Name;
break;
}
}
// Not found - use the default Sans Serif font
if (_defaultFamilyName == null)
{
_defaultFamilyName = FontFamily.GenericSansSerif.Name;
}
}
return _defaultFamilyName;
}
}
#endregion
#region Fields
// Cached fonts dictionary
private Dictionary<KeyInfo, Font> _fontCache = new Dictionary<KeyInfo, Font>(new KeyInfo.EqualityComparer());
#endregion // Fields
#region Properties
/// <summary>
/// Gets the default font.
/// </summary>
/// <value>The default font.</value>
public Font DefaultFont
{
get { return this.GetFont(DefaultFamilyName, 8); }
}
/// <summary>
/// Gets the default font.
/// </summary>
/// <value>The default font.</value>
public Font DefaultBoldFont
{
get { return this.GetFont(DefaultFamilyName, 8, FontStyle.Bold); }
}
#endregion
#region Methods
/// <summary>
/// Gets the font.
/// </summary>
/// <param name="familyName">Name of the family.</param>
/// <param name="size">The size.</param>
/// <returns>Font instance</returns>
public Font GetFont(string familyName, int size)
{
KeyInfo key = new KeyInfo(familyName, size);
if (!this._fontCache.ContainsKey(key))
{
this._fontCache.Add(key, new Font(familyName, size));
}
return this._fontCache[key];
}
/// <summary>
/// Gets the font.
/// </summary>
/// <param name="familyName">Name of the family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
/// <returns>Font instance</returns>
public Font GetFont(string familyName, float size, FontStyle style)
{
KeyInfo key = new KeyInfo(familyName, size, style);
if (!this._fontCache.ContainsKey(key))
{
this._fontCache.Add(key, new Font(familyName, size, style));
}
return this._fontCache[key];
}
/// <summary>
/// Gets the font.
/// </summary>
/// <param name="family">The family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
/// <returns>Font instance</returns>
public Font GetFont(FontFamily family, float size, FontStyle style)
{
KeyInfo key = new KeyInfo(family, size, style);
if (!this._fontCache.ContainsKey(key))
{
this._fontCache.Add(key, new Font(family, size, style));
}
return this._fontCache[key];
}
/// <summary>
/// Gets the font.
/// </summary>
/// <param name="family">The family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
/// <param name="unit">The unit.</param>
/// <returns>Font instance</returns>
public Font GetFont(FontFamily family, float size, FontStyle style, GraphicsUnit unit)
{
KeyInfo key = new KeyInfo(family, size, style, unit);
if (!this._fontCache.ContainsKey(key))
{
this._fontCache.Add(key, new Font(family, size, style, unit));
}
return this._fontCache[key];
}
#endregion
#region IDisposable Members
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
foreach (Font font in _fontCache.Values)
{
font.Dispose();
}
_fontCache.Clear();
GC.SuppressFinalize(this);
}
#endregion
#region FontKeyInfo struct
/// <summary>
/// Font key info
/// </summary>
private class KeyInfo
{
string _familyName;
float _size = 8;
GraphicsUnit _unit = GraphicsUnit.Point;
FontStyle _style = FontStyle.Regular;
int _gdiCharSet = 1;
/// <summary>
/// Initializes a new instance of the <see cref="KeyInfo"/> class.
/// </summary>
/// <param name="familyName">Name of the family.</param>
/// <param name="size">The size.</param>
public KeyInfo(string familyName, float size)
{
this._familyName = familyName;
this._size = size;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyInfo"/> class.
/// </summary>
/// <param name="familyName">Name of the family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
public KeyInfo(string familyName, float size, FontStyle style)
{
this._familyName = familyName;
this._size = size;
this._style = style;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyInfo"/> class.
/// </summary>
/// <param name="family">The family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
public KeyInfo(FontFamily family, float size, FontStyle style)
{
this._familyName = family.ToString();
this._size = size;
this._style = style;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyInfo"/> class.
/// </summary>
/// <param name="family">The family.</param>
/// <param name="size">The size.</param>
/// <param name="style">The style.</param>
/// <param name="unit">The unit.</param>
public KeyInfo(FontFamily family, float size, FontStyle style, GraphicsUnit unit)
{
this._familyName = family.ToString();
this._size = size;
this._style = style;
this._unit = unit;
}
#region IEquatable<FontKeyInfo> Members
/// <summary>
/// KeyInfo equality comparer
/// </summary>
internal class EqualityComparer : IEqualityComparer<KeyInfo>
{
/// <summary>
/// Determines whether the specified objects are equal.
/// </summary>
/// <param name="x">The first object of type <paramref name="x"/> to compare.</param>
/// <param name="y">The second object of type <paramref name="y"/> to compare.</param>
/// <returns>
/// true if the specified objects are equal; otherwise, false.
/// </returns>
public bool Equals(KeyInfo x, KeyInfo y)
{
return
x._size == y._size &&
x._familyName == y._familyName &&
x._unit == y._unit &&
x._style == y._style &&
x._gdiCharSet == y._gdiCharSet;
}
/// <summary>
/// Returns a hash code for the specified object.
/// </summary>
/// <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.</param>
/// <returns>A hash code for the specified object.</returns>
/// <exception cref="T:System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.</exception>
public int GetHashCode(KeyInfo obj)
{
return obj._familyName.GetHashCode() ^ obj._size.GetHashCode();
}
}
#endregion
}
#endregion
}
#endregion
}
|