/// <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>
/// Update the axes when the specified data point's ActualDependentValue property changes.
/// </summary>
/// <param name="dataPoint">The data point.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
protected override void OnDataPointActualDependentValueChanged(DataPoint dataPoint, IComparable oldValue, IComparable newValue)
{
if (oldValue != null)
{
bool removed = DataPointsByActualDependentValue.Remove(oldValue, dataPoint);
if (removed)
{
DataPointsByActualDependentValue.Add(newValue, dataPoint);
}
}
UpdateActualDependentAxis();
UpdateDataPoint(dataPoint);
base.OnDataPointActualDependentValueChanged(dataPoint, oldValue, newValue);
}
/// <summary>
/// Called after data points have been loaded from the items source.
/// </summary>
/// <param name="newDataPoints">New active data points.</param>
/// <param name="oldDataPoints">Old inactive data points.</param>
protected override void OnDataPointsChanged(IList <DataPoint> newDataPoints, IList <DataPoint> oldDataPoints)
{
foreach (DataPoint dataPoint in newDataPoints)
{
DataPointsByActualDependentValue.Add(dataPoint.ActualDependentValue, dataPoint);
}
foreach (DataPoint dataPoint in oldDataPoints)
{
DataPointsByActualDependentValue.Remove(dataPoint.ActualDependentValue, dataPoint);
}
GetAxes();
if (InternalActualDependentAxis != null && InternalActualIndependentAxis != null)
{
Action action = () =>
{
AxesInvalidated = false;
UpdatingAllAxes = true;
try
{
UpdateActualIndependentAxis();
UpdateActualDependentAxis();
}
finally
{
UpdatingAllAxes = false;
}
if (AxesInvalidated)
{
UpdateDataPoints(ActiveDataPoints);
}
else
{
UpdateDataPoints(newDataPoints);
}
AxesInvalidated = false;
};
InvokeOnLayoutUpdated(action);
}
base.OnDataPointsChanged(newDataPoints, oldDataPoints);
}
/// <summary>
/// Returns the actual range of data for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the range for.</param>
/// <returns>The actual range of data.</returns>
protected virtual Range <IComparable> GetRange(IRangeConsumer consumer)
{
if (consumer == null)
{
throw new ArgumentNullException("consumer");
}
if (consumer == InternalActualDependentAxis)
{
if (DataPointsByActualDependentValue.Count > 0)
{
return(DataPointsByActualDependentValue.GetKeyRange());
}
}
var axis = consumer as IAxis;
return((axis != null)
? ActiveDataPoints.Select(dataPoint => (IComparable)GetActualDataPointAxisValue(dataPoint, axis))
.GetRange()
: new Range <IComparable>());
}
