/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="consumer">
/// The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
double dependentValueMargin = ActualHeight / 10;
var axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func <DataPoint, IComparable> selector = null;
if (axis == InternalActualIndependentAxis)
{
selector = dataPoint => (IComparable)dataPoint.ActualIndependentValue;
DataPoint minimumPoint = ActiveDataPoints.MinOrNull(selector);
DataPoint maximumPoint = ActiveDataPoints.MaxOrNull(selector);
double minimumMargin = minimumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(minimumPoint), minimumMargin, minimumMargin));
double maximumMargin = maximumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(maximumPoint), maximumMargin, maximumMargin));
}
else if (axis == InternalActualDependentAxis)
{
selector = dataPoint => dataPoint.ActualDependentValue;
DataPoint minimumPoint = ActiveDataPoints.MinOrNull(selector);
DataPoint maximumPoint = ActiveDataPoints.MaxOrNull(selector);
yield return(new ValueMargin(selector(minimumPoint), dependentValueMargin, dependentValueMargin));
yield return(new ValueMargin(selector(maximumPoint), dependentValueMargin, dependentValueMargin));
}
}
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="consumer">
/// The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
protected virtual IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
var axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func <DataPoint, IComparable> selector = null;
DataPoint minimumPoint = null;
DataPoint maximumPoint = null;
double margin = 0.0;
if (axis == InternalActualIndependentAxis)
{
selector = dataPoint => (IComparable)dataPoint.ActualIndependentValue;
minimumPoint = ActiveDataPoints.MinOrNull(selector);
maximumPoint = ActiveDataPoints.MaxOrNull(selector);
margin = minimumPoint.GetActualMargin(InternalActualIndependentAxis);
}
else if (axis == InternalActualDependentAxis)
{
selector = dataPoint => dataPoint.ActualDependentValue;
Tuple <DataPoint, DataPoint> largestAndSmallestValues =
DataPointsByActualDependentValue.GetLargestAndSmallestValues();
minimumPoint = largestAndSmallestValues.Item1;
maximumPoint = largestAndSmallestValues.Item2;
margin = minimumPoint.GetActualMargin(InternalActualDependentAxis);
}
yield return(new ValueMargin(selector(minimumPoint), margin, margin));
yield return(new ValueMargin(selector(maximumPoint), margin, margin));
}
}
/// <summary>
/// Remove value margins from the side of the data points to ensure
/// that area chart is flush against the edge of the chart.
/// </summary>
/// <param name="consumer">The value margin consumer.</param>
/// <returns>A sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
if (consumer == ActualIndependentAxis)
{
return(Enumerable.Empty <ValueMargin>());
}
return(base.GetValueMargins(consumer));
}
/// <summary>
/// The margins required for each value.
/// </summary>
/// <param name="consumer">The consumer to return the value margins for.</param>
/// <returns>A sequence of margins for each value.</returns>
protected override IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
var axis = consumer as IAxis;
if (axis != null)
{
return(ActiveDataPoints.Select(dataPoint =>
{
double margin = dataPoint.GetMargin(axis);
return new ValueMargin(
GetActualDataPointAxisValue(dataPoint, axis),
margin,
margin);
}));
}
return(Enumerable.Empty <ValueMargin>());
}
/// <summary>
/// Updates the value margins after all data points are updated.
/// </summary>
protected override void OnAfterUpdateDataPoints()
{
IValueMarginProvider provider = this as IValueMarginProvider;
{
IValueMarginConsumer consumer = ActualDependentRangeAxis as IValueMarginConsumer;
if (consumer != null)
{
consumer.ValueMarginsChanged(provider, GetValueMargins(consumer));
}
}
{
IValueMarginConsumer consumer = ActualIndependentAxis as IValueMarginConsumer;
if (consumer != null)
{
consumer.ValueMarginsChanged(provider, GetValueMargins(consumer));
}
}
base.OnAfterUpdateDataPoints();
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (valueMarginConsumer == ActualIndependentAxis)
{
return(Enumerable.Empty <ValueMargin>());
}
else
{
return(base.IValueMarginProviderGetValueMargins(valueMarginConsumer));
}
}
protected override IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
double dependentValueMargin = this.ActualHeight / 10;
IAxis axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func <DataPoint, IComparable> selector = null;
if (axis == InternalActualIndependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualIndependentValue;
DataPoint minimumPoint = ActiveDataPoints.MinOrNull(selector);
DataPoint maximumPoint = ActiveDataPoints.MaxOrNull(selector);
double minimumMargin = minimumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(minimumPoint), minimumMargin, minimumMargin));
double maximumMargin = maximumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(maximumPoint), maximumMargin, maximumMargin));
}
else if (axis == InternalActualDependentAxis)
{
IEnumerable <StackedColumnSeries> columnSeries = SeriesHost.Series.OfType <StackedColumnSeries>().Where(series => series.ActualIndependentAxis == ActualIndependentAxis);
IList <double> maximums = new List <double>();
IList <double> minimums = new List <double>();
foreach (StackedColumnSeries currSeries in columnSeries)
{
for (int i = 0; i < currSeries.ActiveDataPointCount; i++)
{
if (maximums.Count <= i)
{
maximums.Add(0.0);
}
if (minimums.Count <= i)
{
minimums.Add(0.0);
}
DataPoint currDataPoint = currSeries.ActiveDataPoints.ElementAt <DataPoint>(i);
if ((double)currDataPoint.ActualDependentValue > 0)
{
maximums[i] += (double)currDataPoint.ActualDependentValue;
}
else
{
minimums[i] += (double)currDataPoint.ActualDependentValue;
}
}
}
double maximum = 0.0;
double minimum = 0.0;
for (int i = 0; i < minimums.Count; i++)
{
if (maximums[i] > maximum)
{
maximum = maximums[i];
}
if (minimums[i] < minimum)
{
minimum = minimums[i];
}
}
yield return(new ValueMargin(minimum, dependentValueMargin, dependentValueMargin));
yield return(new ValueMargin(maximum, dependentValueMargin, dependentValueMargin));
}
}
else
{
yield break;
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable<ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (valueMarginConsumer == ActualIndependentAxis)
{
return Enumerable.Empty<ValueMargin>();
}
else
{
return base.IValueMarginProviderGetValueMargins(valueMarginConsumer);
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>
/// Sequence of value margins.
/// </returns>
protected override IEnumerable <ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (UseMargins)
{
return(base.IValueMarginProviderGetValueMargins(valueMarginConsumer));
}
else
{
return(Enumerable.Empty <ValueMargin>());
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable<ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (IsStacked100 && (valueMarginConsumer == ActualDependentAxis))
{
return Enumerable.Empty<ValueMargin>();
}
else if ((valueMarginConsumer == ActualDependentAxis) || (valueMarginConsumer == ActualIndependentAxis))
{
Range<IComparable> range = IRangeProviderGetRange((IRangeConsumer)valueMarginConsumer);
double margin = DataItems
.Select(di =>
{
return (null != di.DataPoint) ?
(valueMarginConsumer == ActualDependentAxis) ? di.DataPoint.ActualHeight : di.DataPoint.ActualWidth :
0;
})
.Average() * (3.0 / 4.0);
return new ValueMargin[]
{
new ValueMargin(range.Minimum, margin, margin),
new ValueMargin(range.Maximum, margin, margin),
};
}
else
{
return base.IValueMarginProviderGetValueMargins(valueMarginConsumer);
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable<ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (valueMarginConsumer == ActualDependentAxis)
{
if (IsStacked100)
{
return Enumerable.Empty<ValueMargin>();
}
else
{
Range<IComparable> range = IRangeProviderGetRange((IRangeConsumer)ActualDependentAxis);
double margin = ((AxisOrientation.Y == ActualDependentAxis.Orientation) ? ActualHeight : ActualWidth) / 10;
return new ValueMargin[]
{
new ValueMargin(range.Minimum, margin, margin),
new ValueMargin(range.Maximum, margin, margin),
};
}
}
else if (valueMarginConsumer == ActualIndependentAxis)
{
// Using a non-ICategoryAxis for the independent axis
// Relevant space already accounted for by IRangeProviderGetRange
return Enumerable.Empty<ValueMargin>();
}
else
{
return base.IValueMarginProviderGetValueMargins(valueMarginConsumer);
}
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="axis">The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
IEnumerable<ValueMargin> IValueMarginProvider.GetValueMargins(IValueMarginConsumer axis)
{
return GetValueMargins(axis);
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
protected virtual IEnumerable<ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
IAxis axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func<DataPoint, IComparable> selector = null;
DataPoint minimumPoint = null;
DataPoint maximumPoint = null;
double margin = 0.0;
if (axis == InternalActualIndependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualIndependentValue;
minimumPoint = ActiveDataPoints.MinOrNull(selector);
maximumPoint = ActiveDataPoints.MaxOrNull(selector);
margin = minimumPoint.GetActualMargin(this.InternalActualIndependentAxis);
}
else if (axis == InternalActualDependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualDependentValue;
Tuple<DataPoint, DataPoint> largestAndSmallestValues = this.DataPointsByActualDependentValue.GetLargestAndSmallestValues();
minimumPoint = largestAndSmallestValues.Item1;
maximumPoint = largestAndSmallestValues.Item2;
margin = minimumPoint.GetActualMargin(this.InternalActualDependentAxis);
}
yield return new ValueMargin(selector(minimumPoint), margin, margin);
yield return new ValueMargin(selector(maximumPoint), margin, margin);
}
else
{
yield break;
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (valueMarginConsumer == ActualDependentAxis)
{
if (IsStacked100)
{
return(Enumerable.Empty <ValueMargin>());
}
else
{
Range <IComparable> range = IRangeProviderGetRange((IRangeConsumer)ActualDependentAxis);
double margin = ((AxisOrientation.Y == ActualDependentAxis.Orientation) ? ActualHeight : ActualWidth) / 10;
return(new ValueMargin[]
{
new ValueMargin(range.Minimum, margin, margin),
new ValueMargin(range.Maximum, margin, margin),
});
}
}
else if (valueMarginConsumer == ActualIndependentAxis)
{
// Using a non-ICategoryAxis for the independent axis
// Relevant space already accounted for by IRangeProviderGetRange
return(Enumerable.Empty <ValueMargin>());
}
else
{
return(base.IValueMarginProviderGetValueMargins(valueMarginConsumer));
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
IEnumerable<ValueMargin> IValueMarginProvider.GetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
return IValueMarginProviderGetValueMargins(valueMarginConsumer);
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected virtual IEnumerable<ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
throw new NotImplementedException();
}
/// <summary>
/// The margins required for each value.
/// </summary>
/// <param name="consumer">The consumer to return the value margins for.</param>
/// <returns>A sequence of margins for each value.</returns>
protected override IEnumerable<ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
IAxis axis = consumer as IAxis;
if (axis != null)
{
return ActiveDataPoints.Select(dataPoint =>
{
double margin = dataPoint.GetMargin(axis);
return new ValueMargin(
GetActualDataPointAxisValue(dataPoint, axis),
margin,
margin);
});
}
return Enumerable.Empty<ValueMargin>();
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="axis">The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
IEnumerable <ValueMargin> IValueMarginProvider.GetValueMargins(IValueMarginConsumer axis)
{
return(GetValueMargins(axis));
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (IsStacked100 && (valueMarginConsumer == ActualDependentAxis))
{
return(Enumerable.Empty <ValueMargin>());
}
else if ((valueMarginConsumer == ActualDependentAxis) || (valueMarginConsumer == ActualIndependentAxis))
{
Range <IComparable> range = IRangeProviderGetRange((IRangeConsumer)valueMarginConsumer);
double margin = DataItems
.Select(di =>
{
return((null != di.DataPoint) ?
(valueMarginConsumer == ActualDependentAxis) ? di.DataPoint.ActualHeight : di.DataPoint.ActualWidth :
0);
})
.Average() * (3.0 / 4.0);
return(new ValueMargin[]
{
new ValueMargin(range.Minimum, margin, margin),
new ValueMargin(range.Maximum, margin, margin),
});
}
else
{
return(base.IValueMarginProviderGetValueMargins(valueMarginConsumer));
}
}
