/// <summary>
/// Overrides the actual range.
/// </summary>
/// <param name="range">The range to potentially override.</param>
/// <returns>The overridden range.</returns>
protected virtual Range <IComparable> OverrideActualRange(Range <IComparable> range)
{
if (range.HasData)
{
IComparable minimum = ProtectedMinimum ?? range.Minimum;
IComparable maximum = ProtectedMaximum ?? range.Maximum;
if (ValueHelper.Compare(minimum, maximum) > 0)
{
IComparable temp = maximum;
maximum = minimum;
minimum = temp;
}
return(new Range <IComparable>(minimum, maximum));
}
else
{
IComparable minimum = ProtectedMinimum;
IComparable maximum = ProtectedMaximum;
if (ProtectedMinimum != null && ProtectedMaximum == null)
{
maximum = minimum;
}
else if (ProtectedMaximum != null && ProtectedMinimum == null)
{
minimum = maximum;
}
else
{
return(range);
}
return(new Range <IComparable>(minimum, maximum));
}
}
/// <summary>
/// Returns a sequence of major axis values.
/// </summary>
/// <param name="availableSize">The available size.</param>
/// <returns>
/// A sequence of major axis values.
/// </returns>
private IEnumerable <double> GetMajorValues(Size availableSize)
{
if (!ActualRange.HasData || ValueHelper.Compare(ActualRange.Minimum, ActualRange.Maximum) == 0 ||
GetLength(availableSize) == 0.0)
{
yield break;
}
Range <double> typedActualRange = ActualRange;
ActualInterval = CalculateActualInterval(availableSize);
double startValue = AlignToInterval(typedActualRange.Minimum, ActualInterval);
if (startValue < typedActualRange.Minimum)
{
startValue = AlignToInterval(typedActualRange.Minimum + ActualInterval, ActualInterval);
}
double nextValue = startValue;
for (int counter = 1; nextValue <= typedActualRange.Maximum; counter++)
{
yield return(nextValue);
nextValue = startValue + (counter * ActualInterval);
}
}
/// <summary>
/// Returns a sequence of major values.
/// </summary>
/// <param name="availableSize">The available size.</param>
/// <returns>A sequence of major values.</returns>
protected virtual IEnumerable <DateTime> GetMajorAxisValues(Size availableSize)
{
if (!ActualRange.HasData || ValueHelper.Compare(ActualRange.Minimum, ActualRange.Maximum) == 0 || GetLength(availableSize) == 0.0)
{
yield break;
}
this.ActualInterval = CalculateActualInterval(availableSize);
Range <DateTime> dateTimeRange = ToDateTimeRange(ActualRange);
DateTime date = dateTimeRange.Minimum;
DateTime start = AlignIntervalStart(dateTimeRange.Minimum, this.ActualInterval, ActualIntervalType);
while (start < dateTimeRange.Minimum)
{
start = IncrementDateTime(start, this.ActualInterval);
}
IEnumerable <DateTime> intermediateDates =
EnumerableFunctions
.Iterate(start, next => IncrementDateTime(next, this.ActualInterval))
.TakeWhile(current => dateTimeRange.Contains(current));
foreach (DateTime current in intermediateDates)
{
yield return(current);
}
}
/// <summary>
/// Modifies a range to respect the minimum and maximum axis values.
/// </summary>
/// <param name="range">The range of data.</param>
/// <returns>A range modified to respect the minimum and maximum axis
/// values.</returns>
private Range <IComparable> EnforceMaximumAndMinimum(Range <IComparable> range)
{
if (range.HasData)
{
IComparable minimum = ProtectedMinimum ?? range.Minimum;
IComparable maximum = ProtectedMaximum ?? range.Maximum;
if (ValueHelper.Compare(minimum, maximum) > 0)
{
IComparable temp = maximum;
maximum = minimum;
minimum = temp;
}
return(new Range <IComparable>(minimum, maximum));
}
else
{
IComparable minimum = ProtectedMinimum;
IComparable maximum = ProtectedMaximum;
if (ProtectedMinimum != null && ProtectedMaximum == null)
{
maximum = minimum;
}
else if (ProtectedMaximum != null && ProtectedMinimum == null)
{
minimum = maximum;
}
else
{
return(range);
}
return(new Range <IComparable>(minimum, maximum));
}
}
internal Comparison <object> GetXValueKeyComparison()
{
return((Comparison <object>)((left, right) =>
{
if (left == null && right == null)
{
return 0;
}
if (right == null)
{
return 1;
}
if (left == null)
{
return -1;
}
if (left.Equals(right))
{
return 0;
}
IComparable left1 = left as IComparable;
IComparable right1 = right as IComparable;
if (left1 != null || right1 != null)
{
return ValueHelper.Compare(left1, right1);
}
return RuntimeHelpers.GetHashCode(right).CompareTo(RuntimeHelpers.GetHashCode(left));
}));
}
/// <summary>
/// Returns a sequence of major axis values.
/// </summary>
/// <param name="availableSize">The available size.</param>
/// <returns>A sequence of major axis values.
/// </returns>
private IEnumerable <double> GetMajorValues(Size availableSize)
{
if (!ActualRange.HasData || ValueHelper.Compare(ActualRange.Minimum, ActualRange.Maximum) == 0 || GetLength(availableSize) == 0.0)
{
yield break;
}
foreach (var c in MajorValues.Split(new [] { ';' }))
{
yield return(double.Parse(c));
}
}
/// <summary>
/// Overrides the actual range to ensure that it is never set to an
/// empty range.
/// </summary>
/// <param name="range">The range to override.</param>
/// <returns>Returns the overridden range.</returns>
protected override Range <IComparable> OverrideActualRange(Range <IComparable> range)
{
Range <IComparable> overriddenActualRange = base.OverrideActualRange(range);
if (!overriddenActualRange.HasData)
{
return(new Range <IComparable>(0.0, 1.0));
}
else if (ValueHelper.Compare(overriddenActualRange.Minimum, overriddenActualRange.Maximum) == 0)
{
return(new Range <IComparable>(((double)overriddenActualRange.Minimum) - 1, ((double)overriddenActualRange.Maximum) + 1));
}
return(overriddenActualRange);
}
/// <summary>
/// Overrides the actual range to ensure that it is never set to an
/// empty range.
/// </summary>
/// <param name="range">The range to override.</param>
/// <returns>The overridden range.</returns>
protected override Range <IComparable> OverrideActualRange(Range <IComparable> range)
{
Range <IComparable> overriddenActualRange = base.OverrideActualRange(range);
if (!overriddenActualRange.HasData)
{
int year = DateTime.Now.Year;
return(new Range <IComparable>(new DateTime(year, 1, 1), new DateTime(year + 1, 1, 1)));
}
else if (ValueHelper.Compare(overriddenActualRange.Minimum, overriddenActualRange.Maximum) == 0)
{
DateTime minimum = (DateTime)overriddenActualRange.Minimum;
int year = minimum.Year;
if (ValueHelper.Compare(overriddenActualRange.Minimum, overriddenActualRange.Maximum) == 0)
{
return(new Range <IComparable>(new DateTime(year, 1, 1), new DateTime(year + 1, 1, 1)));
}
}
return(overriddenActualRange);
}
internal override void AdjustDataPointLabelVisibilityRating(LabelVisibilityManager.DataPointRange range, Dictionary <XYDataPoint, double> dataPointRanks)
{
if (range.DataPoints.Count <= 0)
{
return;
}
XYDataPoint xyDataPoint = range.DataPoints[0] as XYDataPoint;
foreach (XYDataPoint key in range.DataPoints)
{
if (ValueHelper.Compare(key.XValue as IComparable, xyDataPoint.XValue as IComparable) == 0)
{
if (dataPointRanks.ContainsKey(key))
{
dataPointRanks[key] = 100.0;
}
else
{
dataPointRanks.Add(key, 100.0);
}
}
}
}
/// <summary>
/// Returns a sequence of major axis values.
/// </summary>
/// <returns>A sequence of major axis values.
/// </returns>
private IEnumerable <double> GetMajorValues()
{
if (!ActualRange.HasData || ValueHelper.Compare(ActualRange.Minimum, ActualRange.Maximum) == 0 || ActualLength == 0.0)
{
yield break;
}
Range <double> typedActualRange = ToDoubleRange(ActualRange);
this.ActualInterval = CalculateActualInterval();
double startValue = AlignToInterval(typedActualRange.Minimum, this.ActualInterval);
if (startValue < typedActualRange.Minimum)
{
startValue = AlignToInterval(typedActualRange.Minimum + this.ActualInterval, this.ActualInterval);
}
double nextValue = startValue;
for (int counter = 1; nextValue <= typedActualRange.Maximum; counter++)
{
yield return(nextValue);
nextValue = startValue + (counter * this.ActualInterval);
}
}
/// <summary>
/// Overrides the actual range to ensure that it is never set to an
/// empty range.
/// </summary>
/// <param name="range">The range to override.</param>
/// <returns>Returns the overridden range.</returns>
protected override Range <IComparable> OverrideDataRange(Range <IComparable> range)
{
range = base.OverrideDataRange(range);
if (!range.HasData)
{
return(new Range <IComparable>(0.0, 1.0));
}
else if (ValueHelper.Compare(range.Minimum, range.Maximum) == 0)
{
Range <IComparable> outputRange = new Range <IComparable>((ValueHelper.ToDouble(range.Minimum)) - 1, (ValueHelper.ToDouble(range.Maximum)) + 1);
return(outputRange);
}
// ActualLength of 1.0 or less maps all points to the same coordinate
if (range.HasData && this.ActualLength > 1.0)
{
bool isDataAnchoredToOrigin = false;
IList <ValueMarginCoordinateAndOverlap> valueMargins = new List <ValueMarginCoordinateAndOverlap>();
foreach (IValueMarginProvider valueMarginProvider in this.RegisteredListeners.OfType <IValueMarginProvider>())
{
foreach (ValueMargin valueMargin in valueMarginProvider.GetValueMargins(this))
{
IAnchoredToOrigin dataAnchoredToOrigin = valueMarginProvider as IAnchoredToOrigin;
isDataAnchoredToOrigin = (dataAnchoredToOrigin != null && dataAnchoredToOrigin.AnchoredAxis == this);
valueMargins.Add(
new ValueMarginCoordinateAndOverlap
{
ValueMargin = valueMargin,
});
}
}
if (valueMargins.Count > 0)
{
double maximumPixelMarginLength =
valueMargins
.Select(valueMargin => valueMargin.ValueMargin.LowMargin + valueMargin.ValueMargin.HighMargin)
.MaxOrNullable().Value;
// Requested margin is larger than the axis so give up
// trying to find a range that will fit it.
if (maximumPixelMarginLength > this.ActualLength)
{
return(range);
}
Range <double> originalRange = range.ToDoubleRange();
Range <double> currentRange = range.ToDoubleRange();
// Ensure range is not empty.
if (currentRange.Minimum == currentRange.Maximum)
{
currentRange = new Range <double>(currentRange.Maximum - 1, currentRange.Maximum + 1);
}
// priming the loop
double actualLength = this.ActualLength;
ValueMarginCoordinateAndOverlap maxLeftOverlapValueMargin;
ValueMarginCoordinateAndOverlap maxRightOverlapValueMargin;
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
GetMaxLeftAndRightOverlap(valueMargins, out maxLeftOverlapValueMargin, out maxRightOverlapValueMargin);
while (maxLeftOverlapValueMargin.LeftOverlap > 0 || maxRightOverlapValueMargin.RightOverlap > 0)
{
double unitOverPixels = currentRange.GetLength().Value / actualLength;
double newMinimum = currentRange.Minimum - ((maxLeftOverlapValueMargin.LeftOverlap + 0.5) * unitOverPixels);
double newMaximum = currentRange.Maximum + ((maxRightOverlapValueMargin.RightOverlap + 0.5) * unitOverPixels);
currentRange = new Range <double>(newMinimum, newMaximum);
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
ValueMarginCoordinateAndOverlap newMaxLeftOverlapValueMargin;
ValueMarginCoordinateAndOverlap newMaxRightOverlapValueMargin;
GetMaxLeftAndRightOverlap(valueMargins, out newMaxLeftOverlapValueMargin, out newMaxRightOverlapValueMargin);
if (newMaxLeftOverlapValueMargin.LeftOverlap == maxLeftOverlapValueMargin.LeftOverlap &&
newMaxRightOverlapValueMargin.RightOverlap == maxRightOverlapValueMargin.RightOverlap)
{
// guard against infinite loop!
break;
}
}
if (isDataAnchoredToOrigin)
{
if (originalRange.Minimum >= 0 && currentRange.Minimum < 0)
{
currentRange = new Range <double>(0, currentRange.Maximum);
}
else if (originalRange.Maximum <= 0 && currentRange.Maximum > 0)
{
currentRange = new Range <double>(currentRange.Minimum, 0);
}
}
return(currentRange.ToComparableRange());
}
}
return(range);
}
protected override Range <IComparable> OverrideDataRange(Range <IComparable> range)
{
Range <IComparable> overriddenActualRange = range;
if (!overriddenActualRange.HasData)
{
int year = DateTime.Now.Year;
return(new Range <IComparable>(new DateTime(year, 1, 1), new DateTime(year + 1, 1, 1)));
}
else if (ValueHelper.Compare(overriddenActualRange.Minimum, overriddenActualRange.Maximum) == 0)
{
DateTime minimum = ValueHelper.ToDateTime(overriddenActualRange.Minimum);
DateTime midpoint = ((DateTime.MinValue == minimum) ? DateTime.Now : minimum).Date;
return(new Range <IComparable>(midpoint.AddMonths(-6), midpoint.AddMonths(6)));
}
// ActualLength of 1.0 or less maps all points to the same coordinate
if (range.HasData && this.ActualLength > 1.0)
{
IList <ValueMarginCoordinateAndOverlap> valueMargins = new List <ValueMarginCoordinateAndOverlap>();
foreach (ValueMargin valueMargin in
this.RegisteredListeners
.OfType <IValueMarginProvider>()
.SelectMany(provider => provider.GetValueMargins(this)))
{
valueMargins.Add(
new ValueMarginCoordinateAndOverlap
{
ValueMargin = valueMargin,
});
}
if (valueMargins.Count > 0)
{
double maximumPixelMarginLength =
valueMargins
.Select(valueMargin => valueMargin.ValueMargin.LowMargin + valueMargin.ValueMargin.HighMargin)
.MaxOrNullable().Value;
// Requested margin is larger than the axis so give up
// trying to find a range that will fit it.
if (maximumPixelMarginLength > this.ActualLength)
{
return(range);
}
Range <DateTime> currentRange = range.ToDateTimeRange();
// Ensure range is not empty.
if (currentRange.Minimum == currentRange.Maximum)
{
int year = DateTime.Now.Year;
currentRange = new Range <DateTime>(new DateTime(year, 1, 1), new DateTime(year + 1, 1, 1));
}
// priming the loop
double actualLength = this.ActualLength;
ValueMarginCoordinateAndOverlap maxLeftOverlapValueMargin;
ValueMarginCoordinateAndOverlap maxRightOverlapValueMargin;
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
GetMaxLeftAndRightOverlap(valueMargins, out maxLeftOverlapValueMargin, out maxRightOverlapValueMargin);
while (maxLeftOverlapValueMargin.LeftOverlap > 0 || maxRightOverlapValueMargin.RightOverlap > 0)
{
long unitOverPixels = currentRange.GetLength().Value.Ticks / ((long)actualLength);
DateTime newMinimum = new DateTime(currentRange.Minimum.Ticks - (long)((maxLeftOverlapValueMargin.LeftOverlap + 0.5) * unitOverPixels));
DateTime newMaximum = new DateTime(currentRange.Maximum.Ticks + (long)((maxRightOverlapValueMargin.RightOverlap + 0.5) * unitOverPixels));
currentRange = new Range <DateTime>(newMinimum, newMaximum);
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
GetMaxLeftAndRightOverlap(valueMargins, out maxLeftOverlapValueMargin, out maxRightOverlapValueMargin);
}
return(currentRange.ToComparableRange());
}
}
return(range);
}
protected override void UpdateView(DataPoint dataPoint)
{
if (!this.IsDataPointViewVisible(dataPoint))
{
return;
}
DateTime now = DateTime.Now;
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (xyDataPoint != null && this.CanGraph(xyDataPoint))
{
DataPointView view = dataPoint.View;
if (view != null)
{
FrameworkElement mainView = view.MainView;
if (mainView != null)
{
bool flag = this.ChartArea.Orientation != Orientation.Horizontal;
RectOrientation rectOrientation = RectOrientation.BottomTop;
Point positionInAxisUnits = this.GetPositionInAxisUnits(xyDataPoint);
Point point1 = new Point(Math.Round(positionInAxisUnits.X), Math.Round(positionInAxisUnits.Y));
object crossingPosition = this.Series.YAxis.Scale.ActualCrossingPosition;
Point basePoint = new Point(positionInAxisUnits.X, this.Series.YAxis.AxisPresenter.ConvertDataToAxisUnits(crossingPosition) ?? 0.0);
Point point2 = new Point(Math.Round(basePoint.X), Math.Round(basePoint.Y));
double num1 = point1.X + Math.Round(this.PointClusterOffset);
double num2 = this.MinMaxScreenCoordinates(positionInAxisUnits.Y);
double num3 = Math.Round(this.PointWidth);
double height = this.MinMaxScreenCoordinates(basePoint.Y - positionInAxisUnits.Y);
if (ValueHelper.Compare(xyDataPoint.YValue as IComparable, crossingPosition as IComparable) != 0 && Math.Abs(height) < 2.0 && this.CanAdjustHeight())
{
height = basePoint.Y - positionInAxisUnits.Y >= 0.0 ? 2.0 : -2.0;
num2 = point2.Y - height;
}
if (height < 0.0)
{
rectOrientation = RectOrientation.TopBottom;
height = Math.Abs(height);
num2 -= height;
}
double num4 = this.MinMaxScreenCoordinates(this.GetYOffsetInAxisUnits(xyDataPoint, positionInAxisUnits, basePoint));
double num5 = Math.Round(num2 - num4);
double num6 = this.AdjustColumnHeight(height);
if (flag)
{
if (rectOrientation == RectOrientation.BottomTop)
{
rectOrientation = RectOrientation.RightLeft;
}
else if (rectOrientation == RectOrientation.TopBottom)
{
rectOrientation = RectOrientation.LeftRight;
}
Canvas.SetLeft((UIElement)mainView, num5);
Canvas.SetTop((UIElement)mainView, num1);
mainView.Width = num6;
mainView.Height = num3;
view.AnchorRect = new Rect(num5, num1, num6, num3);
view.AnchorPoint = rectOrientation != RectOrientation.RightLeft ? new Point(num5 + num6, num1 + this.PointWidth / 2.0) : new Point(num5, num1 + this.PointWidth / 2.0);
}
else
{
Canvas.SetLeft((UIElement)mainView, num1);
Canvas.SetTop((UIElement)mainView, num5);
mainView.Width = num3;
mainView.Height = num6;
view.AnchorRect = new Rect(num1, num5, num3, num6);
view.AnchorPoint = rectOrientation != RectOrientation.BottomTop ? new Point(num1 + this.PointWidth / 2.0, num5 + num6) : new Point(num1 + this.PointWidth / 2.0, num5);
}
BarControl barControl = mainView as BarControl;
if (barControl != null)
{
barControl.Orientation = rectOrientation;
}
view.AnchorRectOrientation = rectOrientation;
}
}
}
base.UpdateView(dataPoint);
if (this.ChartArea == null)
{
return;
}
this.ChartArea.UpdateSession.AddCounter("ColumnSeriesPresenter.UpdateView", DateTime.Now - now);
}
