internal virtual void AddMarkersPosition(CommonElements common, ChartArea area)
{
if (smartLabelsPositions.Count != 0 || area == null)
{
return;
}
ChartTypeRegistry chartTypeRegistry = common.ChartTypeRegistry;
foreach (Series item in common.DataManager.Series)
{
if (item.ChartArea == area.Name && item.SmartLabels.Enabled && !item.SmartLabels.MarkerOverlapping)
{
chartTypeRegistry.GetChartType(item.ChartTypeName).AddSmartLabelMarkerPositions(common, area, item, smartLabelsPositions);
}
}
Axis[] axes = area.Axes;
foreach (Axis axis in axes)
{
if (!(axis.ScaleBreakStyle.Spacing > 0.0) || axis.ScaleSegments.Count <= 0)
{
continue;
}
for (int j = 0; j < axis.ScaleSegments.Count - 1; j++)
{
RectangleF breakLinePosition = axis.ScaleSegments[j].GetBreakLinePosition(common.graph, axis.ScaleSegments[j + 1]);
breakLinePosition = common.graph.GetRelativeRectangle(breakLinePosition);
if (smartLabelsPositions == null)
{
smartLabelsPositions = new ArrayList();
}
smartLabelsPositions.Add(breakLinePosition);
}
}
}
/// <summary>
/// Fill in the list of chart type names.
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Standard values collection.</returns>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ChartTypeRegistry registry = null;
ArrayList values = new ArrayList();
Chart chart = ConverterHelper.GetChartFromContext(context);
if (chart != null)
{
// Get chart type registry service
registry = (ChartTypeRegistry)chart.GetService(typeof(ChartTypeRegistry));
if (registry != null)
{
// Enumerate all chart types names
foreach (Object obj in registry.registeredChartTypes.Keys)
{
if (obj is string)
{
values.Add(obj);
}
}
}
else
{
throw (new InvalidOperationException(SR.ExceptionEditorChartTypeRegistryServiceInaccessible));
}
}
// Sort all values
values.Sort();
return(new StandardValuesCollection(values));
}
public virtual void AddMarkersPosition(CommonElements common, ChartArea area)
{
if (this.smartLabelsPositions.Count == 0 && area != null)
{
ChartTypeRegistry chartTypeRegistry = common.ChartTypeRegistry;
foreach (Series item in common.DataManager.Series)
{
if (item.ChartArea == area.Name && item.SmartLabels.Enabled && !item.SmartLabels.MarkerOverlapping)
{
IChartType chartType = chartTypeRegistry.GetChartType(item.ChartTypeName);
chartType.AddSmartLabelMarkerPositions(common, area, item, this.smartLabelsPositions);
}
}
Axis[] axes = area.Axes;
foreach (Axis axis in axes)
{
if (axis.ScaleBreakStyle.Spacing > 0.0 && axis.ScaleSegments.Count > 0)
{
for (int j = 0; j < axis.ScaleSegments.Count - 1; j++)
{
RectangleF breakLinePosition = axis.ScaleSegments[j].GetBreakLinePosition(common.graph, axis.ScaleSegments[j + 1]);
breakLinePosition = common.graph.GetRelativeRectangle(breakLinePosition);
if (this.smartLabelsPositions == null)
{
this.smartLabelsPositions = new ArrayList();
}
this.smartLabelsPositions.Add(breakLinePosition);
}
}
}
}
}
/// <summary>
/// Override this function to support chart type drawing
/// </summary>
/// <param name="context">Descriptor context.</param>
/// <returns>Can paint values.</returns>
public override bool GetPaintValueSupported(ITypeDescriptorContext context)
{
// Initialize the chartTypeRegistry using context
if (context != null && context.Instance != null)
{
IChartElement chartElement = context.Instance as IChartElement;
if (chartElement != null)
{
this._chartTypeRegistry = chartElement.Common.ChartTypeRegistry;
}
}
// Always return true
return(true);
}
/// <summary>
/// Gets minimum Unsigned stacked Y value from many series
/// </summary>
/// <param name="valueIndex">Index of Y value to use</param>
/// <param name="series">Series IDs</param>
/// <returns>Minimum stacked Y value</returns>
internal double GetMinUnsignedStackedYValue(int valueIndex, params string[] series)
{
double returnValue = Double.MaxValue;
double minValue = Double.MaxValue;
double numberOfPoints = GetNumberOfPoints(series);
for (int pointIndex = 0; pointIndex < numberOfPoints; pointIndex++)
{
double stackedMin = 0;
double noStackedMin = 0;
minValue = Double.MaxValue;
foreach (string seriesName in series)
{
if (this._series[seriesName].Points.Count > pointIndex)
{
// Take chart type from the series
ChartTypeRegistry chartTypeRegistry = (ChartTypeRegistry)serviceContainer.GetService(typeof(ChartTypeRegistry));
IChartType chartType = chartTypeRegistry.GetChartType(this._series[seriesName].ChartTypeName);
// If stacked column and bar
if (chartType.StackSign || double.IsNaN(this._series[seriesName].Points[pointIndex].YValues[valueIndex]))
{
continue;
}
if (chartType.Stacked)
{
if (this._series[seriesName].Points[pointIndex].YValues[valueIndex] < 0)
{
stackedMin += this._series[seriesName].Points[pointIndex].YValues[valueIndex];
if (stackedMin < minValue)
{
minValue = stackedMin;
}
}
}
else
{
noStackedMin = Math.Min(noStackedMin, this._series[seriesName].Points[pointIndex].YValues[valueIndex]);
}
}
}
minValue = Math.Min(noStackedMin, minValue);
returnValue = Math.Min(returnValue, minValue);
}
return(returnValue);
}
public double GetMinUnsignedStackedYValue(int valueIndex, params string[] series)
{
double num = 1.7976931348623157E+308;
double num2 = 1.7976931348623157E+308;
double num3 = (double)this.GetNumberOfPoints(series);
for (int i = 0; (double)i < num3; i++)
{
double num4 = 0.0;
double val = 0.0;
num2 = 1.7976931348623157E+308;
foreach (string parameter in series)
{
if (this.series[parameter].Points.Count > i)
{
ChartTypeRegistry chartTypeRegistry = (ChartTypeRegistry)this.serviceContainer.GetService(typeof(ChartTypeRegistry));
IChartType chartType = chartTypeRegistry.GetChartType(this.series[parameter].ChartTypeName);
if (!chartType.StackSign && !double.IsNaN(this.series[parameter].Points[i].YValues[valueIndex]))
{
if (chartType.Stacked)
{
if (this.series[parameter].Points[i].YValues[valueIndex] < 0.0)
{
num4 += this.series[parameter].Points[i].YValues[valueIndex];
if (num4 < num2)
{
num2 = num4;
}
}
}
else
{
val = Math.Min(val, this.series[parameter].Points[i].YValues[valueIndex]);
}
}
}
}
num2 = Math.Min(val, num2);
num = Math.Min(num, num2);
}
return(num);
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ChartTypeRegistry chartTypeRegistry = null;
ArrayList arrayList = new ArrayList();
if (context != null && context.Instance != null)
{
IServiceContainer serviceContainer = null;
if (context.Instance is Series && ((Series)context.Instance).serviceContainer != null)
{
serviceContainer = ((Series)context.Instance).serviceContainer;
}
if (serviceContainer == null && context.Instance is Array)
{
Array array = (Array)context.Instance;
if (array.Length > 0 && array.GetValue(0) is Series)
{
serviceContainer = ((Series)array.GetValue(0)).serviceContainer;
}
}
if (serviceContainer != null)
{
chartTypeRegistry = (ChartTypeRegistry)serviceContainer.GetService(typeof(ChartTypeRegistry));
if (chartTypeRegistry != null)
{
foreach (object key in chartTypeRegistry.registeredChartTypes.Keys)
{
if (key is string)
{
arrayList.Add(key);
}
}
goto IL_0106;
}
throw new InvalidOperationException(SR.ExceptionEditorChartTypeRegistryServiceInaccessible);
}
}
goto IL_0106;
IL_0106:
arrayList.Sort();
return(new StandardValuesCollection(arrayList));
}
/// <summary>
/// Gets maximum stacked Y value from many series
/// </summary>
/// <param name="valueIndex">Index of Y value to use</param>
/// <param name="series">Series IDs</param>
/// <returns>Maximum stacked Y value</returns>
internal double GetMaxStackedYValue(int valueIndex, params string[] series)
{
double returnValue = 0;
double numberOfPoints = GetNumberOfPoints(series);
for (int pointIndex = 0; pointIndex < numberOfPoints; pointIndex++)
{
double stackedMax = 0;
double noStackedMax = 0;
foreach (string seriesName in series)
{
if (this._series[seriesName].Points.Count > pointIndex)
{
// Take chart type from the series
ChartTypeRegistry chartTypeRegistry = (ChartTypeRegistry)serviceContainer.GetService(typeof(ChartTypeRegistry));
IChartType chartType = chartTypeRegistry.GetChartType(this._series[seriesName].ChartTypeName);
// If stacked area
if (!chartType.StackSign)
{
continue;
}
if (chartType.Stacked)
{
if (this._series[seriesName].Points[pointIndex].YValues[valueIndex] > 0)
{
stackedMax += this._series[seriesName].Points[pointIndex].YValues[valueIndex];
}
}
else
{
noStackedMax = Math.Max(noStackedMax, this._series[seriesName].Points[pointIndex].YValues[valueIndex]);
}
}
}
stackedMax = Math.Max(stackedMax, noStackedMax);
returnValue = Math.Max(returnValue, stackedMax);
}
return(returnValue);
}
public double GetMaxStackedYValue(int valueIndex, params string[] series)
{
double num = 0.0;
double num2 = (double)this.GetNumberOfPoints(series);
for (int i = 0; (double)i < num2; i++)
{
double num3 = 0.0;
double num4 = 0.0;
foreach (string parameter in series)
{
if (this.series[parameter].Points.Count > i)
{
ChartTypeRegistry chartTypeRegistry = (ChartTypeRegistry)this.serviceContainer.GetService(typeof(ChartTypeRegistry));
IChartType chartType = chartTypeRegistry.GetChartType(this.series[parameter].ChartTypeName);
if (chartType.StackSign)
{
if (chartType.Stacked)
{
if (this.series[parameter].Points[i].YValues[valueIndex] > 0.0)
{
num3 += this.series[parameter].Points[i].YValues[valueIndex];
}
}
else
{
num4 = Math.Max(num4, this.series[parameter].Points[i].YValues[valueIndex]);
}
}
}
}
num3 = Math.Max(num3, num4);
num = Math.Max(num, num3);
}
return(num);
}
/// <summary>
/// Gets chart type image.
/// </summary>
/// <param name="registry">Chart types registry object.</param>
/// <returns>Chart type image.</returns>
override public System.Drawing.Image GetImage(ChartTypeRegistry registry)
{
return((System.Drawing.Image)registry.ResourceManager.GetObject(this.Name + "ChartType"));
}
