/// <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); }