|
//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
// Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
// File: AxisConverter.cs
//
// Namespace: DataVisualization.Charting.Design
//
// Classes: AxisLabelDateValueConverter, AxisCrossingValueConverter
// AxisMinMaxValueConverter, AxisMinMaxAutoValueConverter,
// StripLineTitleAngleConverter
//
// Purpose: Converters for the Axis object properties.
//
// Reviewed: AG - August 7, 2002
//
//===================================================================
#region Used Namespaces
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Collections;
using System.Globalization;
using System.Reflection;
#if Microsoft_CONTROL
using System.Windows.Forms.DataVisualization.Charting;
#else
using System.Web;
using System.Web.UI;
using System.Web.UI.DataVisualization.Charting;
using System.Web.UI.DataVisualization.Charting.Data;
using System.Web.UI.DataVisualization.Charting.ChartTypes;
#endif
#endregion
#if Microsoft_CONTROL
namespace System.Windows.Forms.DataVisualization.Charting
#else
namespace System.Web.UI.DataVisualization.Charting
#endif
{
/// <summary>
/// Converts labels, grid and ticks start position to support dates format
/// </summary>
internal class AxisLabelDateValueConverter : DoubleConverter
{
#region Converter methods
/// <summary>
/// Convert Min and Max values to string if step type is set to one of the DateTime type
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert.</param>
/// <param name="destinationType">Convertion destination type.</param>
/// <returns>Converted object.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context != null && context.Instance != null)
{
// Convert to string
if (destinationType == typeof(string))
{
DateTimeIntervalType intervalType = DateTimeIntervalType.Auto;
double interval = 0;
// Get IntervalType property using reflection
PropertyInfo propertyInfo = context.Instance.GetType().GetProperty("IntervalType");
if(propertyInfo != null)
{
intervalType = (DateTimeIntervalType)propertyInfo.GetValue(context.Instance, null);
}
// Get Interval property using reflection
propertyInfo = context.Instance.GetType().GetProperty("Interval");
if(propertyInfo != null)
{
interval = (double)propertyInfo.GetValue(context.Instance, null);
}
// Try to get interval information from the axis
if(intervalType == DateTimeIntervalType.Auto)
{
// Get object's axis
Axis axis = null;
if(context.Instance is Axis)
{
axis = (Axis)context.Instance;
}
else
{
MethodInfo methodInfo = context.Instance.GetType().GetMethod("GetAxis");
if(methodInfo != null)
{
// Get axis object
axis = (Axis)methodInfo.Invoke(context.Instance, null);
}
}
// Get axis value type
if(axis != null)
{
intervalType = axis.GetAxisIntervalType();
}
}
// Convert value to date/time string
if(context.Instance.GetType() != typeof(StripLine) || interval == 0)
{
if(intervalType != DateTimeIntervalType.Number && intervalType != DateTimeIntervalType.Auto)
{
// Covert value to date/time
if(intervalType < DateTimeIntervalType.Hours)
{
return DateTime.FromOADate((double)value).ToShortDateString();
}
return DateTime.FromOADate((double)value).ToString("g", System.Globalization.CultureInfo.CurrentCulture);
}
}
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Convert Min and Max values from string if step type is set to one of the DateTime type
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert from.</param>
/// <returns>Converted object.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
object result = null;
bool convertFromDate = false;
string stringValue = value as string;
// If context interface provided check if we are dealing with DateTime values
if (context != null && context.Instance != null)
{
DateTimeIntervalType intervalType = DateTimeIntervalType.Auto;
// Get intervalType property using reflection
PropertyInfo propertyInfo = context.Instance.GetType().GetProperty("intervalType");
if(propertyInfo != null)
{
intervalType = (DateTimeIntervalType)propertyInfo.GetValue(context.Instance, null);
}
// Try to get interval information from the axis
if(intervalType == DateTimeIntervalType.Auto)
{
// Get object's axis
Axis axis = null;
if(context.Instance is Axis)
{
axis = (Axis)context.Instance;
}
else
{
MethodInfo methodInfo = context.Instance.GetType().GetMethod("GetAxis");
if(methodInfo != null)
{
// Get axis object
axis = (Axis)methodInfo.Invoke(context.Instance, null);
}
}
// Get axis value type
if(axis != null)
{
intervalType = axis.GetAxisIntervalType();
}
}
if (stringValue != null && intervalType != DateTimeIntervalType.Number && intervalType != DateTimeIntervalType.Auto)
{
convertFromDate = true;
}
}
// Try to convert from double string
try
{
result = base.ConvertFrom(context, culture, value);
}
catch (ArgumentException)
{
result = null;
}
catch (NotSupportedException)
{
result = null;
}
// Try to convert from date/time string
if (stringValue != null && (convertFromDate || result == null))
{
DateTime valueAsDate;
bool parseSucceed = DateTime.TryParse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out valueAsDate);
if (parseSucceed)
{
// Succeded converting from date format
return valueAsDate.ToOADate();
}
}
// Call base converter
return base.ConvertFrom(context, culture, value);
}
#endregion
}
/// <summary>
/// Converts crossing property of the axis.
/// Possible values: double, date, "Auto", "Min", "Max"
/// </summary>
internal class AxisCrossingValueConverter : AxisMinMaxValueConverter
{
#region Converter methods
/// <summary>
/// Standart values supported - return true.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standard values supported.</returns>
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// Standart values are not exclusive - return false
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Non exclusive standard values.</returns>
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
/// <summary>
/// Fill in the list of standart values.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standart values collection.</returns>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList values = new ArrayList();
values.Add(Double.NaN);
values.Add(Double.MinValue);
values.Add(Double.MaxValue);
return new StandardValuesCollection(values);
}
/// <summary>
/// Convert crossing value to string.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert.</param>
/// <param name="destinationType">Convertion destination type.</param>
/// <returns>Converted object.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
double doubleValue = (double)value;
if (destinationType == typeof(string))
{
if(Double.IsNaN(doubleValue))
{
return Constants.AutoValue;
}
else if(doubleValue == Double.MinValue)
{
return Constants.MinValue;
}
else if(doubleValue == Double.MaxValue)
{
return Constants.MaxValue;
}
}
// Call base class
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Convert crossing values from string
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert from.</param>
/// <returns>Converted object.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
// If converting from string value
string crossingValue = value as string;
if (crossingValue != null)
{
if (String.Compare(crossingValue, Constants.AutoValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return Double.NaN;
}
else if (String.Compare(crossingValue, Constants.MinValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return Double.MinValue;
}
else if (String.Compare(crossingValue, Constants.MaxValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return Double.MaxValue;
}
}
// Call base converter
return base.ConvertFrom(context, culture, value);
}
#endregion
}
/// <summary>
/// Converts min and max properties of the axis depending on the values type
/// </summary>
internal class AxisMinMaxValueConverter : DoubleConverter
{
#region Converter methods
/// <summary>
/// Convert Min and Max values to string if step type is set to one of the DateTime type
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert.</param>
/// <param name="destinationType">Convertion destination type.</param>
/// <returns>Converted object.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context != null && context.Instance != null && context.Instance is Axis)
{
Axis axis = (Axis)context.Instance;
if (destinationType == typeof(string))
{
string strValue = DoubleDateNanValueConverter.ConvertDateTimeToString(
(double)value,
axis.GetAxisValuesType(),
axis.InternalIntervalType);
if (strValue != null)
return strValue;
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Convert Min and Max values from string if step type is set to one of the DateTime type
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert from.</param>
/// <returns>Converted object.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
object result = null;
bool convertFromDate = false;
string stringValue = value as string;
// If context interface provided check if we are dealing with DateTime values
if (context != null && context.Instance != null && context.Instance is Axis)
{
Axis axis = (Axis)context.Instance;
if (stringValue != null)
{
if (axis.InternalIntervalType == DateTimeIntervalType.Auto)
{
if (axis.GetAxisValuesType() == ChartValueType.DateTime ||
axis.GetAxisValuesType() == ChartValueType.Date ||
axis.GetAxisValuesType() == ChartValueType.Time ||
axis.GetAxisValuesType() == ChartValueType.DateTimeOffset)
{
convertFromDate = true;
}
}
else
{
if (axis.InternalIntervalType != DateTimeIntervalType.Number)
{
convertFromDate = true;
}
}
}
}
// Try to convert from double string
try
{
result = base.ConvertFrom(context, culture, value);
}
catch (ArgumentException)
{
result = null;
}
catch (NotSupportedException)
{
result = null;
}
// Try to convert from date/time string
if (stringValue != null && (convertFromDate || result == null))
{
DateTime valueAsDate;
bool parseSucceed = DateTime.TryParse(stringValue, CultureInfo.CurrentCulture, DateTimeStyles.None, out valueAsDate);
if (parseSucceed)
{
return valueAsDate.ToOADate();
}
}
// Call base converter
return base.ConvertFrom(context, culture, value);
}
#endregion
}
/// <summary>
/// Converts maximum and minimum property of the axis.
/// Possible values: double, date, "Auto",
/// </summary>
internal class AxisMinMaxAutoValueConverter : AxisMinMaxValueConverter
{
#region Converter methods
/// <summary>
/// Standart values supported - return true
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standard values supported.</returns>
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// Standart values are not exclusive - return false
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Non exclusive standard values.</returns>
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
/// <summary>
/// Fill in the list of data series names.
/// </summary>
/// <param name="context">Descriptor context.</param>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList values = new ArrayList();
values.Add(Double.NaN);
return new StandardValuesCollection(values);
}
/// <summary>
/// Convert minimum or maximum value to string
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert.</param>
/// <param name="destinationType">Convertion destination type.</param>
/// <returns>Converted object.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
double doubleValue = (double)value;
if (destinationType == typeof(string))
{
if(Double.IsNaN(doubleValue))
{
return Constants.AutoValue;
}
}
// Call base class
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Convert minimum or maximum values from string
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
// If converting from string value
string crossingValue = value as string;
if (crossingValue != null)
{
if (String.Compare(crossingValue, Constants.AutoValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return Double.NaN;
}
}
// Call base converter
return base.ConvertFrom(context, culture, value);
}
#endregion
}
/// <summary>
/// Converts title angle property of the strip line
/// Possible values: 0, 90, 180, 270
/// </summary>
internal class StripLineTitleAngleConverter : Int32Converter
{
#region Converter methods
/// <summary>
/// Standart values supported - return true
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standard values supported.</returns>
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// Standart values are not exclusive - return false
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Non exclusive standard values.</returns>
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// Fill in the list of data series names.
/// </summary>
/// <param name="context">Descriptor context.</param>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList values = new ArrayList();
values.Add(0);
values.Add(90);
values.Add(180);
values.Add(270);
return new StandardValuesCollection(values);
}
#endregion
}
/// <summary>
/// Converts Interval and IntervalOffset properties of the axis
/// </summary>
internal class AxisIntervalValueConverter : DoubleConverter
{
#region Converter methods
/// <summary>
/// Inicates that "NotSet" option is available
/// </summary>
internal bool hideNotSet = true;
/// <summary>
/// Standart values supported - return true.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standard values supported.</returns>
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// Standart values are not exclusive - return false
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Non exclusive standard values.</returns>
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
/// <summary>
/// Fill in the list of standart values.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standart values collection.</returns>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList values = new ArrayList();
if(!hideNotSet)
{
values.Add(Double.NaN);
}
values.Add(0.0);
return new StandardValuesCollection(values);
}
/// <summary>
/// Convert crossing value to string.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert.</param>
/// <param name="destinationType">Convertion destination type.</param>
/// <returns>Converted object.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
double doubleValue = (double)value;
if (destinationType == typeof(string))
{
if(Double.IsNaN(doubleValue))
{
return Constants.NotSetValue;
}
else if(doubleValue == 0.0)
{
return Constants.AutoValue;
}
}
// Call base class
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Convert crossing values from string
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Value to convert from.</param>
/// <returns>Converted object.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
// If converting from string value
string crossingValue = value as string;
if (crossingValue != null)
{
if (String.Compare(crossingValue, Constants.AutoValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return 0.0;
}
else if (String.Compare(crossingValue, Constants.NotSetValue, StringComparison.OrdinalIgnoreCase) == 0)
{
return Double.NaN;
}
}
// Call base converter
return base.ConvertFrom(context, culture, value);
}
#endregion
}
/// <summary>
/// Converts Interval and IntervalOffset properties of the label style, tick marks and grids
/// </summary>
internal class AxisElementIntervalValueConverter : AxisIntervalValueConverter
{
/// <summary>
/// Show the NotSet option for interval
/// </summary>
public AxisElementIntervalValueConverter()
{
base.hideNotSet = false;
}
}
}
|