public virtual bool CanPlot(DataPoint dataPoint)
{
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (this.ActualXValueType == DataValueType.Category)
{
if (xyDataPoint != null)
{
return(this.XAggregator.CanPlot(xyDataPoint.XValue));
}
return(false);
}
if (this.ActualYValueType == DataValueType.Category)
{
if (xyDataPoint != null)
{
return(this.YAggregator.CanPlot(xyDataPoint.XValue));
}
return(false);
}
if (xyDataPoint != null && this.XAggregator.CanPlot(xyDataPoint.XValue))
{
return(this.YAggregator.CanPlot(xyDataPoint.YValue));
}
return(false);
}
internal override FrameworkElement GetLegendSymbol()
{
FrameworkElement viewElement = this.CreateViewElement();
XYDataPoint xyDataPoint = Enumerable.FirstOrDefault <XYDataPoint>(Enumerable.Where <XYDataPoint>(Enumerable.OfType <XYDataPoint>((IEnumerable)this.Series.DataPoints), (Func <XYDataPoint, bool>)(p =>
{
if (!p.ActualIsEmpty)
{
return(p.IsVisible);
}
return(false);
})));
if (xyDataPoint != null)
{
this.BindViewToDataPoint((DataPoint)xyDataPoint, viewElement, (string)null);
}
else
{
xyDataPoint = this.Series.CreateDataPoint() as XYDataPoint;
xyDataPoint.Series = (Series)this.Series;
if (this.Series.ItemsBinder != null)
{
this.Series.ItemsBinder.Bind((DataPoint)xyDataPoint, this.Series.DataContext);
}
this.BindViewToDataPoint((DataPoint)xyDataPoint, viewElement, (string)null);
xyDataPoint.Series = (Series)null;
}
viewElement.Opacity = xyDataPoint.Opacity;
viewElement.Effect = xyDataPoint.Effect;
viewElement.Width = 20.0;
viewElement.Height = 12.0;
return(viewElement);
}
internal override void UpdateDataPointVisibility()
{
int index1 = 0;
DataPointViewState[] dataPointViewStateArray = new DataPointViewState[this.Series.DataPoints.Count];
foreach (DataPoint dataPoint in (Collection <DataPoint>) this.Series.DataPoints)
{
DataPointViewState dataPointViewState = DataPointViewState.Hidden;
dataPoint.IsVisible = false;
XYDataPoint dataPointXY = dataPoint as XYDataPoint;
if (dataPointXY != null && this.ChartArea != null && (this.ChartArea.IsTemplateApplied && this.CanGraph(dataPointXY)) && this.Series.Visibility == Visibility.Visible)
{
dataPoint.IsVisible = true;
dataPointViewState = dataPoint.IsNewlyAdded ? DataPointViewState.Showing : DataPointViewState.Normal;
this.ChartArea.UpdateSession.Update((IUpdatable)dataPoint);
}
dataPointViewStateArray[index1] = dataPointViewState;
++index1;
}
this.CheckSimplifiedRenderingMode();
int index2 = 0;
foreach (DataPoint dataPoint in (Collection <DataPoint>) this.Series.DataPoints)
{
this.SetDataPointViewState(dataPoint, dataPointViewStateArray[index2]);
dataPoint.IsNewlyAdded = false;
++index2;
}
}
private Dictionary <XYDataPoint, double> GetDefaultRanking(LabelVisibilityManager.DataPointRange range, LabelVisibilityManager.DataPointRange prevRange, ref bool useMaximum)
{
Dictionary <XYDataPoint, double> dictionary = new Dictionary <XYDataPoint, double>();
if (!range.ProjectedYRange.HasData)
{
double num1 = 0.05;
if (prevRange != null && prevRange.DataPointProjectedYRange.HasData && range.DataPointProjectedYRange.HasData)
{
if (range.DataPointProjectedYRange.Maximum - prevRange.DataPointProjectedYRange.Maximum > num1 && range.DataPointProjectedYRange.Minimum - prevRange.DataPointProjectedYRange.Minimum > num1)
{
useMaximum = true;
}
else if (prevRange.DataPointProjectedYRange.Maximum - range.DataPointProjectedYRange.Maximum > num1 && prevRange.DataPointProjectedYRange.Minimum - range.DataPointProjectedYRange.Minimum > num1)
{
useMaximum = false;
}
else if (range.DataPointProjectedYRange.Maximum - prevRange.DataPointProjectedYRange.Maximum > num1 && prevRange.DataPointProjectedYRange.Minimum - range.DataPointProjectedYRange.Minimum > num1)
{
double num2 = Math.Abs(range.DataPointProjectedYRange.Maximum - prevRange.DataPointProjectedYRange.Maximum);
double num3 = Math.Abs(range.DataPointProjectedYRange.Minimum - prevRange.DataPointProjectedYRange.Minimum);
useMaximum = num2 > num3;
}
else
{
useMaximum = !useMaximum;
}
}
}
XYDataPoint key = (XYDataPoint)null;
double d = double.NaN;
foreach (XYDataPoint xyDataPoint in range.DataPoints)
{
if (double.IsNaN(d))
{
key = xyDataPoint;
d = xyDataPoint.YValueInScaleUnitsWithoutAnimation;
}
else if (useMaximum && d < xyDataPoint.YValueInScaleUnitsWithoutAnimation)
{
key = xyDataPoint;
d = xyDataPoint.YValueInScaleUnitsWithoutAnimation;
}
else if (!useMaximum && d >= xyDataPoint.YValueInScaleUnitsWithoutAnimation)
{
key = xyDataPoint;
d = xyDataPoint.YValueInScaleUnitsWithoutAnimation;
}
}
if (key != null)
{
dictionary.Add(key, 50.0);
}
if (range.ProjectedYRange.HasData)
{
useMaximum = !useMaximum;
}
return(dictionary);
}
private void ChangeDataPointYValue(XYDataPoint dataPoint, object newValue)
{
if (dataPoint == null)
{
return;
}
double yvalueInScaleUnits = dataPoint.YValueInScaleUnits;
double d = this.Series.YAxis.Scale == null ? double.NaN : this.Series.YAxis.Scale.ProjectDataValue(newValue);
dataPoint.YValueInScaleUnitsWithoutAnimation = d;
if (!double.IsNaN(d) && !double.IsNaN(yvalueInScaleUnits) && (this.IsSeriesAnimationEnabled && this.ChartArea != null))
{
DependencyPropertyAnimationHelper.BeginAnimation(this.ChartArea, "YValueInScaleUnits", (object)yvalueInScaleUnits, (object)d, (Action <object, object>)((value1, value2) =>
{
if (double.IsNaN(dataPoint.YValueInScaleUnitsWithoutAnimation))
{
return;
}
dataPoint.YValueInScaleUnits = (double)value2;
}), dataPoint.Storyboards, this.Series.ActualTransitionDuration, this.Series.ActualTransitionEasingFunction);
}
else
{
this.SkipToFillValueAnimation(dataPoint, "YValueInScaleUnits");
dataPoint.YValueInScaleUnits = d;
}
}
internal virtual bool CanGraph(XYDataPoint dataPointXY)
{
if (ValueHelper.CanGraph(dataPointXY.XValueInScaleUnits) && ValueHelper.CanGraph(dataPointXY.YValueInScaleUnits) && (DoubleHelper.GreaterOrEqualWithPrecision(dataPointXY.XValueInScaleUnits, 0.0) && DoubleHelper.LessOrEqualWithPrecision(dataPointXY.XValueInScaleUnits, 1.0)) && DoubleHelper.GreaterOrEqualWithPrecision(dataPointXY.YValueInScaleUnits, 0.0))
{
return(DoubleHelper.LessOrEqualWithPrecision(dataPointXY.YValueInScaleUnits, 1.0));
}
return(false);
}
internal void SkipToFillValueAnimation(XYDataPoint dataPoint, string propertyName)
{
string storyboardKey = DependencyPropertyAnimationHelper.GetStoryboardKey(propertyName);
StoryboardInfo storyboardInfo = (StoryboardInfo)null;
if (!dataPoint.Storyboards.TryGetValue(storyboardKey, out storyboardInfo) || storyboardInfo.Storyboard.Children.Count <= 0)
{
return;
}
storyboardInfo.Storyboard.SkipToFill();
}
internal Range <IComparable> GetDataPointYValueRange(XYDataPoint p)
{
object index = ValueHelper.ConvertValue(p.XValue, this.Series.ActualXValueType);
Range <IComparable> pointYvalueRange;
if (!this.DataPointsByXValueRanges.TryGetValue(index, out pointYvalueRange))
{
pointYvalueRange = this.GetDataPointYValueRange(index, this.GetCounterpartDataSeries(true));
this.DataPointsByXValueRanges[index] = pointYvalueRange;
}
return(pointYvalueRange);
}
protected override void UpdateView(DataPoint dataPoint)
{
if (this.IsDataPointVisible(dataPoint))
{
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (xyDataPoint.View != null)
{
dataPoint.View.AnchorPoint = this.ChartArea.ConvertScaleToPlotCoordinate(this.Series.XAxis, this.Series.YAxis, xyDataPoint.XValueInScaleUnits, xyDataPoint.YValueInScaleUnits);
this.ChartArea.UpdateSession.ExecuteOnceAfterUpdating((Action)(() => this.UpdateLinePoints()), (object)new Tuple <Series, string>((Series)this.Series, "__UpdateLinePoints__"), (string)null);
}
}
base.UpdateView(dataPoint);
}
internal override void OnDataPointAdded(DataPoint dataPoint, bool useShowingAnimation)
{
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (xyDataPoint == null)
{
return;
}
xyDataPoint.XValueInScaleUnits = this.Series.XAxis.Scale.ProjectDataValue(xyDataPoint.XValue);
xyDataPoint.YValueInScaleUnits = this.Series.YAxis.Scale.ProjectDataValue(xyDataPoint.YValue);
xyDataPoint.XValueInScaleUnitsWithoutAnimation = xyDataPoint.XValueInScaleUnits;
xyDataPoint.YValueInScaleUnitsWithoutAnimation = xyDataPoint.YValueInScaleUnits;
xyDataPoint.IsNewlyAdded = useShowingAnimation;
}
internal override bool CanGraph(XYDataPoint dataPointXY)
{
BubbleDataPoint bubbleDataPoint = dataPointXY as BubbleDataPoint;
if (bubbleDataPoint != null && this.BubbleSeries.IsSizeValueUsed && bubbleDataPoint.IsSizeValueUsed)
{
double doubleValue = 0.0;
if (!ValueHelper.TryConvert(bubbleDataPoint.SizeValue, true, out doubleValue) || !ValueHelper.CanGraph(doubleValue) || DoubleHelper.LessOrEqualWithPrecision(bubbleDataPoint.SizeValueInScaleUnits, 0.0))
{
return(false);
}
}
return(base.CanGraph(dataPointXY));
}
internal override Point GetPositionInAxisUnits(XYDataPoint dataPoint)
{
double x = this.Series.XAxis.AxisPresenter.ConvertScaleToAxisUnits(dataPoint.XValueInScaleUnits) ?? 0.0;
double num = this.TransformYValueInScaleUnits(dataPoint, dataPoint.YValueInScaleUnits);
StackedColumnDataPoint stackedColumnDataPoint = dataPoint as StackedColumnDataPoint;
if (stackedColumnDataPoint != null)
{
stackedColumnDataPoint.YValuePercent = num;
}
double y = this.Series.YAxis.AxisPresenter.ConvertScaleToAxisUnits(num) ?? 0.0;
return(new Point(x, y));
}
protected override void UpdateView(DataPoint dataPoint)
{
if (this.IsDataPointViewVisible(dataPoint))
{
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (xyDataPoint != null && dataPoint.View != null)
{
Point point = this.ChartArea.ConvertScaleToPlotCoordinate(this.Series.XAxis, this.Series.YAxis, xyDataPoint.XValueInScaleUnits, xyDataPoint.YValueInScaleUnits);
point.X = Math.Round(point.X);
point.Y = Math.Round(point.Y);
dataPoint.View.AnchorPoint = point;
}
}
base.UpdateView(dataPoint);
}
protected override string GetNameCore()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.DataPoint.IsSelected)
{
stringBuilder.Append(Resources.DataPointHighlightedScreenReaderContent);
}
stringBuilder.Append(Resources.DataPointDetailsScreenReaderContent);
string str1 = base.GetNameCore();
if (string.IsNullOrEmpty(str1) && this.DataPoint.ToolTipContent != null)
{
str1 = this.DataPoint.ToolTipContent.AutomationName;
}
if (string.IsNullOrEmpty(str1))
{
str1 = this.DataPoint.ActualLabelContent as string;
}
if (string.IsNullOrEmpty(str1) && this.DataPoint is XYDataPoint)
{
XYDataPoint xyDataPoint = (XYDataPoint)this.DataPoint;
if (xyDataPoint.XValue != null)
{
str1 = ((XYDataPoint)this.DataPoint).XValue.ToString();
}
if (xyDataPoint.YValue != null)
{
if (!string.IsNullOrEmpty(str1))
{
str1 += "; ";
}
StringFormatConverter stringFormatConverter = new StringFormatConverter();
string str2 = ValueHelper.PrepareFormatString(xyDataPoint.StringFormat);
str1 += (string)stringFormatConverter.Convert(xyDataPoint.YValue, (Type)null, (object)str2, (CultureInfo)null);
}
}
if (string.IsNullOrEmpty(str1))
{
str1 = this.DataPoint.Name;
}
if (string.IsNullOrEmpty(str1))
{
str1 = this.DataPoint.GetType().Name;
}
stringBuilder.Append(str1);
return(stringBuilder.ToString());
}
private void UpdateLinePoints()
{
if (this.ChartArea == null || !this.IsRootPanelVisible)
{
return;
}
DateTime now = DateTime.Now;
PointCollection pointCollection = new PointCollection();
Collection <IAppearanceProvider> collection = new Collection <IAppearanceProvider>();
XYDataPoint xyDataPoint1 = (XYDataPoint)null;
if (this.Series.Visibility == Visibility.Visible)
{
for (int index = 0; index < this.Series.DataPoints.Count; ++index)
{
XYDataPoint xyDataPoint2 = this.Series.DataPoints[index] as XYDataPoint;
if (xyDataPoint2.View != null && this.IsDataPointVisible((DataPoint)xyDataPoint2) && (this.IsValidScaleUnitValue(xyDataPoint2.XValueInScaleUnits) && this.IsValidScaleUnitValue(xyDataPoint2.YValueInScaleUnits)))
{
if (xyDataPoint1 != null && xyDataPoint1.ActualIsEmpty)
{
collection.Add((IAppearanceProvider)xyDataPoint1);
pointCollection.Add(xyDataPoint2.View.AnchorPoint);
if (index < this.Series.DataPoints.Count - 1)
{
XYDataPoint xyDataPoint3 = this.Series.DataPoints[index + 1] as XYDataPoint;
if (xyDataPoint3.ActualIsEmpty)
{
collection.Add((IAppearanceProvider)xyDataPoint3);
pointCollection.Add(xyDataPoint2.View.AnchorPoint);
}
}
}
collection.Add((IAppearanceProvider)xyDataPoint2);
pointCollection.Add(xyDataPoint2.View.AnchorPoint);
}
xyDataPoint1 = xyDataPoint2;
}
}
if (this.PolylineControl != null)
{
this.PolylineControl.Points = pointCollection;
this.PolylineControl.Appearances = collection;
this.PolylineControl.Update();
}
this.ChartArea.UpdateSession.AddCounter("LineSeriesPresenter.UpdateLinePoints", DateTime.Now - now);
}
private double TransformYValueInScaleUnits(XYDataPoint dataPoint, double yValueInScaleUnits)
{
if (!this.IsHundredPercent(dataPoint))
{
return(yValueInScaleUnits);
}
Range <IComparable> pointYvalueRange = this.GetDataPointYValueRange(dataPoint);
double val2 = (double)ValueHelper.ConvertValue((object)pointYvalueRange.Minimum, DataValueType.Float);
double num = Math.Max(0.0, (double)ValueHelper.ConvertValue((object)pointYvalueRange.Maximum, DataValueType.Float)) - Math.Min(0.0, val2);
NumericScale numericScale = this.Series.YAxis.Scale as NumericScale;
if (num == 0.0)
{
return(this.Series.YAxis.Scale.ProjectDataValue(this.Series.YAxis.Scale.ActualCrossingPosition));
}
Range <double> fromRange = new Range <double>(numericScale.Project(0.0), numericScale.Project(num));
Range <double> targetRange = new Range <double>(numericScale.Project(0.0), numericScale.Project(1.0));
return(RangeHelper.Project(fromRange, yValueInScaleUnits, targetRange));
}
internal static XYDataPoint FindDataPoint(PolylineControl polyline, Point position)
{
XYDataPoint xyDataPoint1 = (XYDataPoint)null;
foreach (IAppearanceProvider appearanceProvider in polyline.Appearances)
{
XYDataPoint xyDataPoint2 = appearanceProvider as XYDataPoint;
if (xyDataPoint2 != null && xyDataPoint2.View != null && !xyDataPoint2.ActualIsEmpty)
{
if (xyDataPoint1 == null)
{
xyDataPoint1 = xyDataPoint2;
}
else if (LineSeriesPresenter.GetDistance(position, xyDataPoint2.View.AnchorPoint) < LineSeriesPresenter.GetDistance(position, xyDataPoint1.View.AnchorPoint))
{
xyDataPoint1 = xyDataPoint2;
}
}
}
return(xyDataPoint1);
}
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);
}
}
}
}
internal override ContentPositions GetAutomaticLabelPosition(DataPoint dataPoint)
{
ContentPositions contentPositions1 = ContentPositions.TopCenter;
ContentPositions contentPositions2 = ContentPositions.BottomCenter;
if (this.SeriesPresenter.ChartArea != null)
{
if (this.SeriesPresenter.ChartArea.Orientation == Orientation.Vertical)
{
contentPositions1 = ContentPositions.MiddleRight;
contentPositions2 = ContentPositions.MiddleLeft;
}
XYDataPoint xyDataPoint1 = dataPoint as XYDataPoint;
int num = this.SeriesPresenter.Series.DataPoints.IndexOf(dataPoint);
XYDataPoint xyDataPoint2 = num > 0 ? this.SeriesPresenter.Series.DataPoints[num - 1] as XYDataPoint : (XYDataPoint)null;
XYDataPoint xyDataPoint3 = num < this.SeriesPresenter.Series.DataPoints.Count - 1 ? this.SeriesPresenter.Series.DataPoints[num + 1] as XYDataPoint : (XYDataPoint)null;
if (xyDataPoint2 != null && xyDataPoint3 != null && (xyDataPoint1.YValueInScaleUnitsWithoutAnimation < xyDataPoint2.YValueInScaleUnitsWithoutAnimation && xyDataPoint1.YValueInScaleUnitsWithoutAnimation < xyDataPoint3.YValueInScaleUnitsWithoutAnimation) || xyDataPoint2 != null && xyDataPoint3 == null && xyDataPoint1.YValueInScaleUnitsWithoutAnimation < xyDataPoint2.YValueInScaleUnitsWithoutAnimation || xyDataPoint2 == null && xyDataPoint3 != null && xyDataPoint1.YValueInScaleUnitsWithoutAnimation < xyDataPoint3.YValueInScaleUnitsWithoutAnimation)
{
return(contentPositions2);
}
}
return(contentPositions1);
}
internal override void AdjustDataPointLabelVisibilityRating(LabelVisibilityManager.DataPointRange range, Dictionary <XYDataPoint, double> dataPointRanks)
{
XYDataPoint key = (XYDataPoint)null;
if (range.DataPoints.Count > 0)
{
key = range.DataPoints[range.DataPoints.Count / 2] as XYDataPoint;
}
if (key == null)
{
return;
}
if (dataPointRanks.ContainsKey(key))
{
Dictionary <XYDataPoint, double> dictionary;
XYDataPoint index;
(dictionary = dataPointRanks)[index = key] = dictionary[index] + 150.0;
}
else
{
dataPointRanks.Add(key, 150.0);
}
}
internal override double GetYOffsetInAxisUnits(XYDataPoint dataPoint, Point valuePoint, Point basePoint)
{
object xValue = ValueHelper.ConvertValue(dataPoint.XValue, ((XYSeries)dataPoint.Series).ActualXValueType);
bool flag = valuePoint.Y < basePoint.Y;
double num1 = 0.0;
double num2 = 0.0;
object clusterGroupKey = ((ColumnSeries)this.Series).ClusterGroupKey;
foreach (XYDataPoint dataPointXY in Enumerable.Where <XYDataPoint>((IEnumerable <XYDataPoint>) this.GetCounterpartDataPoints(xValue, false), (Func <XYDataPoint, bool>)(p => this.IsDataPointViewVisible((DataPoint)p))))
{
ColumnSeries columnSeries = dataPointXY.Series as ColumnSeries;
if (clusterGroupKey != null && columnSeries != null)
{
if (ValueHelper.AreEqual(columnSeries.ClusterGroupKey, clusterGroupKey))
{
break;
}
}
Point positionInAxisUnits = this.GetPositionInAxisUnits(dataPointXY);
if (flag)
{
if (positionInAxisUnits.Y < basePoint.Y)
{
num1 += basePoint.Y - positionInAxisUnits.Y;
}
}
else if (positionInAxisUnits.Y > basePoint.Y)
{
num2 += basePoint.Y - positionInAxisUnits.Y;
}
}
if (!flag)
{
return(num2);
}
return(num1);
}
public virtual void UpdateDataPointLabelVisibility()
{
DateTime now = DateTime.Now;
if (this._xScalePositions == null)
{
this.RecalculateXIntervals();
}
if (this._yScalePositions == null)
{
this.RecalculateYIntervals();
}
if (this._chartArea == null || this._chartArea.Series.Count <= 0)
{
return;
}
if (this._dataPointRanges.Count == 0)
{
this.CreateDataPointRanges();
}
List <XYDataPoint> list = new List <XYDataPoint>();
Dictionary <Type, SeriesPresenter> dictionary = new Dictionary <Type, SeriesPresenter>();
foreach (Series series in this._chartArea.Series)
{
if (!dictionary.ContainsKey(series.SeriesPresenter.GetType()))
{
dictionary.Add(series.SeriesPresenter.GetType(), series.SeriesPresenter);
}
if (series.Visibility == Visibility.Visible && series.LabelVisibility == Visibility.Visible)
{
foreach (XYDataPoint xyDataPoint in ((XYSeriesPresenter)series.SeriesPresenter).Series.DataPointsByXValue)
{
if (xyDataPoint.ActualLabelContent != null && xyDataPoint.XValueInScaleUnitsWithoutAnimation >= 0.0 && (xyDataPoint.XValueInScaleUnitsWithoutAnimation <= 1.0 && xyDataPoint.Visibility == Visibility.Visible))
{
if (this.IsOnlyXAxisUsed)
{
list.Add(xyDataPoint);
}
else if (xyDataPoint.YValueInScaleUnitsWithoutAnimation >= 0.0 && xyDataPoint.YValueInScaleUnitsWithoutAnimation <= 1.0)
{
list.Add(xyDataPoint);
}
}
}
}
}
if (list.Count < 30)
{
foreach (DataPoint dataPoint in list)
{
dataPoint.ActualLabelVisibility = Visibility.Visible;
}
}
else
{
foreach (LabelVisibilityManager.DataPointRange dataPointRange in this._dataPointRanges)
{
dataPointRange.DataPoints.Clear();
dataPointRange.DataPointProjectedYRange = Range <double> .Empty;
for (int index = 0; index < list.Count; ++index)
{
XYDataPoint xyDataPoint = list[index];
if (xyDataPoint.XValueInScaleUnitsWithoutAnimation >= dataPointRange.ProjectedXRange.Minimum && xyDataPoint.XValueInScaleUnitsWithoutAnimation < dataPointRange.ProjectedXRange.Maximum && (!dataPointRange.ProjectedYRange.HasData || xyDataPoint.YValueInScaleUnitsWithoutAnimation >= dataPointRange.ProjectedYRange.Minimum && xyDataPoint.YValueInScaleUnitsWithoutAnimation < dataPointRange.ProjectedYRange.Maximum))
{
dataPointRange.DataPoints.Add((DataPoint)xyDataPoint);
dataPointRange.DataPointProjectedYRange = dataPointRange.DataPointProjectedYRange.Add(xyDataPoint.YValueInScaleUnitsWithoutAnimation);
list.RemoveAt(index);
--index;
}
}
}
foreach (DataPoint dataPoint in list)
{
dataPoint.ActualLabelVisibility = Visibility.Collapsed;
}
bool useMaximum = true;
LabelVisibilityManager.DataPointRange prevRange = (LabelVisibilityManager.DataPointRange)null;
foreach (LabelVisibilityManager.DataPointRange range in this._dataPointRanges)
{
Dictionary <XYDataPoint, double> defaultRanking = this.GetDefaultRanking(range, prevRange, ref useMaximum);
prevRange = range;
foreach (SeriesPresenter seriesPresenter in dictionary.Values)
{
seriesPresenter.LabelPresenter.AdjustDataPointLabelVisibilityRating(range, defaultRanking);
}
double num1 = -1.0;
foreach (double num2 in defaultRanking.Values)
{
if (num2 > num1)
{
num1 = num2;
}
}
foreach (XYDataPoint key in range.DataPoints)
{
double num2;
if (defaultRanking.TryGetValue(key, out num2) && num2 == num1)
{
key.ActualLabelVisibility = Visibility.Visible;
}
else
{
key.ActualLabelVisibility = Visibility.Collapsed;
}
}
}
}
}
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);
}
internal override void UpdateDataPointVisibility()
{
int index1 = 0;
bool flag1 = true;
bool flag2 = true;
DataPointViewState[] dataPointViewStateArray = new DataPointViewState[this.Series.DataPoints.Count];
foreach (DataPoint dataPoint1 in (Collection <DataPoint>) this.Series.DataPoints)
{
DataPointViewState dataPointViewState = DataPointViewState.Hidden;
dataPoint1.IsVisible = false;
XYDataPoint xyDataPoint = dataPoint1 as XYDataPoint;
if (xyDataPoint != null && this.ChartArea != null && (this.ChartArea.IsTemplateApplied && ValueHelper.CanGraph(xyDataPoint.XValueInScaleUnits)) && ValueHelper.CanGraph(xyDataPoint.YValueInScaleUnits))
{
if (DoubleHelper.GreaterOrEqualWithPrecision(xyDataPoint.XValueInScaleUnits, 0.0) && DoubleHelper.LessOrEqualWithPrecision(xyDataPoint.XValueInScaleUnits, 1.0) && (DoubleHelper.GreaterOrEqualWithPrecision(xyDataPoint.YValueInScaleUnits, 0.0) && DoubleHelper.LessOrEqualWithPrecision(xyDataPoint.YValueInScaleUnits, 1.0)))
{
if (this.Series.Visibility == Visibility.Visible)
{
flag1 = false;
dataPoint1.IsVisible = true;
if (!dataPoint1.IsNewlyAdded)
{
flag2 = false;
}
dataPointViewState = dataPoint1.IsNewlyAdded ? DataPointViewState.Showing : DataPointViewState.Normal;
if (index1 > 0)
{
DataPoint dataPoint2 = this.Series.DataPoints[index1 - 1];
if (dataPointViewStateArray[index1 - 1] == DataPointViewState.Hidden || dataPointViewStateArray[index1 - 1] == DataPointViewState.Hiding)
{
dataPoint2.IsVisible = true;
dataPointViewStateArray[index1 - 1] = dataPointViewState;
this.ChartArea.UpdateSession.Update((IUpdatable)dataPoint2);
}
}
if (index1 < this.Series.DataPoints.Count - 1)
{
DataPoint dataPoint2 = this.Series.DataPoints[index1 + 1];
if (!this._dataPointsToForceVisibility.Contains(dataPoint2))
{
this._dataPointsToForceVisibility.Add(dataPoint2);
}
}
this.ChartArea.UpdateSession.Update((IUpdatable)dataPoint1);
}
}
else if (this._dataPointsToForceVisibility.Contains(dataPoint1))
{
dataPoint1.IsVisible = true;
dataPointViewState = dataPoint1.IsNewlyAdded ? DataPointViewState.Showing : DataPointViewState.Normal;
}
}
if (this._dataPointsToForceVisibility.Contains(dataPoint1))
{
this._dataPointsToForceVisibility.Remove(dataPoint1);
}
dataPointViewStateArray[index1] = dataPointViewState;
++index1;
}
this.IsSimplifiedRenderingModeCheckRequired = true;
this.CheckSimplifiedRenderingMode();
if (!flag2)
{
for (int index2 = 0; index2 < EnumerableFunctions.FastCount((IEnumerable)dataPointViewStateArray); ++index2)
{
if (dataPointViewStateArray[index2] == DataPointViewState.Showing)
{
dataPointViewStateArray[index2] = DataPointViewState.Normal;
}
}
}
if (flag1 && this.Series.DataPoints.Count > 0 && (this.ChartArea != null && this.ChartArea.IsTemplateApplied) && (DoubleHelper.LessWithPrecision(((XYDataPoint)this.Series.DataPoints[0]).XValueInScaleUnits, 0.0) && DoubleHelper.GreaterWithPrecision(((XYDataPoint)this.Series.DataPoints[this.Series.DataPoints.Count - 1]).XValueInScaleUnits, 1.0)))
{
int index2;
for (index2 = 1; index2 < this.Series.DataPoints.Count - 2; ++index2)
{
if (DoubleHelper.GreaterOrEqualWithPrecision((this.Series.DataPoints[index2] as XYDataPoint).XValueInScaleUnits, 0.0))
{
--index2;
break;
}
}
XYDataPoint xyDataPoint1 = this.Series.DataPoints[index2] as XYDataPoint;
xyDataPoint1.IsVisible = true;
dataPointViewStateArray[index2] = xyDataPoint1.IsNewlyAdded ? DataPointViewState.Showing : DataPointViewState.Normal;
this.ChartArea.UpdateSession.Update((IUpdatable)xyDataPoint1);
XYDataPoint xyDataPoint2 = this.Series.DataPoints[index2 + 1] as XYDataPoint;
xyDataPoint2.IsVisible = true;
dataPointViewStateArray[index2 + 1] = xyDataPoint2.IsNewlyAdded ? DataPointViewState.Showing : DataPointViewState.Normal;
this.ChartArea.UpdateSession.Update((IUpdatable)xyDataPoint2);
}
int index3 = 0;
foreach (DataPoint dataPoint in (Collection <DataPoint>) this.Series.DataPoints)
{
this.SetDataPointViewState(dataPoint, dataPointViewStateArray[index3]);
dataPoint.IsNewlyAdded = false;
++index3;
}
}
internal virtual Point GetPositionInAxisUnits(XYDataPoint dataPointXY)
{
return(new Point(this.Series.XAxis.AxisPresenter.ConvertScaleToAxisUnits(dataPointXY.XValueInScaleUnits) ?? 0.0, this.Series.YAxis.AxisPresenter.ConvertScaleToAxisUnits(dataPointXY.YValueInScaleUnits) ?? 0.0));
}
internal virtual double GetYOffsetInAxisUnits(XYDataPoint dataPoint, Point valuePoint, Point basePoint)
{
return(0.0);
}
private bool IsHundredPercent(XYDataPoint dataPoint)
{
return(this.IsHundredPercent(dataPoint.Series));
}
