You've already forked linux-packaging-mono
0cb742dafb
Rewrite with hard-coded offsets into the PE file format to discern if a binary is PE32 or PE32+, and then to determine if it contains a "CLR Data Directory" entry that looks valid. Tested with PE32 and PE32+ compiled Mono binaries, PE32 and PE32+ native binaries, and a random assortment of garbage files. Former-commit-id: 9e7ac86ec84f653a2f79b87183efd5b0ebda001b
4362 lines
128 KiB
C#
4362 lines
128 KiB
C#
//-------------------------------------------------------------
|
||
// <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
|
||
|
||
|
||
}
|