/// <summary>
/// Updates the values of the rating items.
/// </summary>
private void UpdateValues()
{
IList <RatingItem> ratingItems = GetRatingItems().ToList();
RatingItem oldSelectedItem = this.GetSelectedRatingItem();
IEnumerable <Tuple <RatingItem, double> > itemAndWeights =
EnumerableFunctions
.Zip(
ratingItems,
ratingItems
.Select(ratingItem => 1.0)
.GetWeightedValues(WeightedValue),
(item, percent) => Tuple.Create(item, percent));
foreach (Tuple <RatingItem, double> itemAndWeight in itemAndWeights)
{
itemAndWeight.Item1.Value = itemAndWeight.Item2;
}
RatingItem newSelectedItem = this.GetSelectedRatingItem();
if (HoveredRatingItem == null)
{
DisplayValue = WeightedValue;
}
}
/// <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);
}
}
private Series GetNextSeries(FrameworkElement element, bool isForward)
{
Series series = (Series)null;
if (element is DataPoint)
{
series = ((DataPoint)element).Series;
}
else
{
List <Series> list = new List <Series>(this.ChartArea.GetSeries());
if (element is Series && list.Contains((Series)element))
{
int num = EnumerableFunctions.IndexOf((IEnumerable)list, (object)element);
int index = !isForward ? num - 1 : num + 1;
if (index < 0)
{
index = list.Count - 1;
}
else if (index > list.Count - 1)
{
index = 0;
}
series = list[index];
}
if (series == null && list.Count > 0)
{
series = list[0];
}
}
return(series);
}
private void PopulateLayers()
{
if (this.ParentPanel == null)
{
return;
}
EnumerableFunctions.ForEachWithIndex <Panel>((IEnumerable <Panel>) this._layers.Values, (Action <Panel, int>)((item, index) => this.AddChildPanel((UIElement)item)));
}
public void RemoveAllLayers()
{
if (this._parentPanel != null)
{
EnumerableFunctions.ForEachWithIndex <Panel>((IEnumerable <Panel>) this._layers.Values, (Action <Panel, int>)((item, index) => this.ParentPanel.Children.Remove((UIElement)item)));
}
this._layers.Clear();
}
protected virtual void CreateView()
{
EnumerableFunctions.ForEachWithIndex <AxisPresenter.AxisPanelType>((IEnumerable <AxisPresenter.AxisPanelType>) this.PanelsDictionary.Keys, (Action <AxisPresenter.AxisPanelType, int>)((item, index) => this.GetAxisPanel(item)));
this.SetBinding(AxisPresenter.VisibilityListenerProperty, (BindingBase) new Binding("Visibility")
{
Source = (object)this.Axis
});
}
internal override bool CheckSimplifiedRenderingMode()
{
bool flag = base.CheckSimplifiedRenderingMode();
if (flag)
{
EnumerableFunctions.ForEach <DataPoint>(this.VisibleDataPoints, (Action <DataPoint>)(item => this.UpdateView(item)));
}
return(flag);
}
protected virtual void OnVisibilityListenerPropertyChanged(object oldValue, object newValue)
{
if ((Visibility)newValue == Visibility.Collapsed)
{
EnumerableFunctions.ForEach <UIElement>(Enumerable.OfType <UIElement>((IEnumerable)Enumerable.Select <AxisPresenter.AxisPanelType, Panel>((IEnumerable <AxisPresenter.AxisPanelType>) this.PanelsDictionary.Keys, (Func <AxisPresenter.AxisPanelType, Panel>)(panelType => this.GetAxisPanel(panelType)))), (Action <UIElement>)(item => item.Visibility = Visibility.Collapsed));
}
else
{
EnumerableFunctions.ForEach <UIElement>(Enumerable.OfType <UIElement>((IEnumerable)Enumerable.Select <AxisPresenter.AxisPanelType, Panel>((IEnumerable <AxisPresenter.AxisPanelType>) this.PanelsDictionary.Keys, (Func <AxisPresenter.AxisPanelType, Panel>)(panelType => this.GetAxisPanel(panelType)))), (Action <UIElement>)(item => item.ClearValue(UIElement.VisibilityProperty)));
}
}
internal bool ShouldSimplifiedRenderingModeBeEnabled()
{
int num = this.Series.SimplifiedRenderingThreshold ?? this.DefaultSimplifiedRenderingThreshold;
if (num == 0)
{
return(true);
}
if (this.Series.DataPoints.Count >= num)
{
return(EnumerableFunctions.FastCount((IEnumerable)this.VisibleDataPoints) >= num);
}
return(false);
}
internal virtual Dictionary <object, List <Series> > GroupSeriesByClusters(IList <XYSeries> clusterSeries)
{
Dictionary <object, List <Series> > clusterGroups = new Dictionary <object, List <Series> >();
foreach (ColumnSeries columnSeries1 in (IEnumerable <XYSeries>)clusterSeries)
{
List <Series> list = new List <Series>();
if (columnSeries1.ClusterGroupKey == null)
{
list.Add((Series)columnSeries1);
clusterGroups.Add((object)new Tuple <ColumnSeries>(columnSeries1), list);
}
else if (!clusterGroups.ContainsKey(columnSeries1.ClusterGroupKey))
{
foreach (ColumnSeries columnSeries2 in (IEnumerable <XYSeries>)clusterSeries)
{
if (ValueHelper.AreEqual(columnSeries2.ClusterGroupKey, columnSeries1.ClusterGroupKey))
{
list.Add((Series)columnSeries2);
}
}
clusterGroups.Add(columnSeries1.ClusterGroupKey, list);
}
}
IList <StackedColumnSeries> list1 = (IList <StackedColumnSeries>)Enumerable.ToList <StackedColumnSeries>(Enumerable.OfType <StackedColumnSeries>((IEnumerable)Enumerable.Where <XYSeries>((IEnumerable <XYSeries>) this.XYChartArea.Series, (Func <XYSeries, bool>)(s => s.Visibility == Visibility.Visible))));
foreach (List <Series> list2 in clusterGroups.Values)
{
List <Series> groupSeries = list2;
EnumerableFunctions.ForEach <Series>(Enumerable.Where <Series>((IEnumerable <Series>)groupSeries.ToArray(), (Func <Series, bool>)(s => s is StackedColumnSeries)), (Action <Series>)(s => groupSeries.Remove(s)));
}
EnumerableFunctions.ForEach <KeyValuePair <object, List <Series> > >(Enumerable.Where <KeyValuePair <object, List <Series> > >((IEnumerable <KeyValuePair <object, List <Series> > >)Enumerable.ToArray <KeyValuePair <object, List <Series> > >((IEnumerable <KeyValuePair <object, List <Series> > >)clusterGroups), (Func <KeyValuePair <object, List <Series> >, bool>)(item => item.Value.Count == 0)), (Action <KeyValuePair <object, List <Series> > >)(item => clusterGroups.Remove(item.Key)));
foreach (StackedColumnSeries series1 in (IEnumerable <StackedColumnSeries>)list1)
{
List <Series> list2 = new List <Series>();
Tuple <DataValueType, DataValueType, bool, object> seriesKey = StackedColumnSeriesPresenter.GetSeriesKey(series1);
if (!clusterGroups.ContainsKey((object)seriesKey) && seriesKey.Item1 != DataValueType.Auto)
{
foreach (StackedColumnSeries series2 in (IEnumerable <StackedColumnSeries>)list1)
{
if (StackedColumnSeriesPresenter.GetSeriesKey(series2).Equals((object)seriesKey))
{
list2.Add((Series)series2);
}
}
clusterGroups.Add((object)seriesKey, list2);
}
}
return(clusterGroups);
}
internal void UpdateIsAnySeriesHaveSelectionFlag()
{
if (this.SuspendSelectionChangedEventsCount != 0)
{
return;
}
bool seriesHaveSelection = this.IsAnySeriesHaveSelection;
this.IsAnySeriesHaveSelection = Enumerable.FirstOrDefault <Series>(this.GetSeries(), (Func <Series, bool>)(s => s.HaveSelectedDataPoints)) != null;
if (seriesHaveSelection == this.IsAnySeriesHaveSelection)
{
return;
}
EnumerableFunctions.ForEach <Series>(this.GetSeries(), (Action <Series>)(s => s.UpdateSeriesSelectionStateFromChart()));
}
protected override void Populate(double availableLength)
{
this._majorGridLinePool.ReleaseAll();
this._minorGridLinePool.ReleaseAll();
if (this.Presenter.IsMinorGridlinesVisible)
{
this._majorGridLinePool.AdjustPoolSize();
}
try
{
this.PrepareOppositeAxisLine();
foreach (ScaleElementDefinition elementDefinition in (IEnumerable <ScaleElementDefinition>) new List <ScaleElementDefinition>((IEnumerable <ScaleElementDefinition>)Enumerable.OrderBy <ScaleElementDefinition, int>(Enumerable.Where <ScaleElementDefinition>(this.Presenter.GetScaleElements(), (Func <ScaleElementDefinition, bool>)(p => p.Kind == ScaleElementKind.Tickmark)), (Func <ScaleElementDefinition, int>)(p => p.Group != ScaleElementGroup.Major ? 0 : 1))))
{
if (elementDefinition.Group == ScaleElementGroup.Major && this.Axis.ShowMajorGridlines)
{
EnumerableFunctions.ForEachWithIndex <ScalePosition>(Enumerable.Where <ScalePosition>(elementDefinition.Positions, (Func <ScalePosition, bool>)(p =>
{
if (p.Position >= 0.0)
{
return(p.Position <= 1.0);
}
return(false);
})), (Action <ScalePosition, int>)((position, index) => XYAxisElementsPanel.SetCoordinate((UIElement)this._majorGridLinePool.Get(this.Axis), position.Position)));
}
if (elementDefinition.Group == ScaleElementGroup.Minor && this.Presenter.IsMinorGridlinesVisible)
{
EnumerableFunctions.ForEachWithIndex <ScalePosition>(Enumerable.Where <ScalePosition>(elementDefinition.Positions, (Func <ScalePosition, bool>)(p =>
{
if (p.Position >= 0.0)
{
return(p.Position <= 1.0);
}
return(false);
})), (Action <ScalePosition, int>)((position, index) => XYAxisElementsPanel.SetCoordinate((UIElement)this._minorGridLinePool.Get(this.Axis), position.Position)));
}
}
}
finally
{
if (!this.Presenter.IsMinorGridlinesVisible)
{
this._majorGridLinePool.AdjustPoolSize();
}
this._minorGridLinePool.AdjustPoolSize();
}
}
protected override void UpdateRelatedSeriesPresenters()
{
this.ChartArea.UpdateSession.BeginUpdates();
if (this.XYChartArea != null)
{
EnumerableFunctions.ForEachWithIndex <XYSeries>(Enumerable.Where <XYSeries>((IEnumerable <XYSeries>) this.XYChartArea.Series, (Func <XYSeries, bool>)(item =>
{
if (item.GetType() == this.Series.GetType())
{
return(item != this.Series);
}
return(false);
})), (Action <XYSeries, int>)((item, index) => this.ChartArea.UpdateSession.Update((IUpdatable)item)));
}
base.UpdateRelatedSeriesPresenters();
this.ChartArea.UpdateSession.EndUpdates();
}
protected override string GetAutomationIdCore()
{
string str = base.GetAutomationIdCore();
if (string.IsNullOrEmpty(str))
{
str = this.GetName();
if (this.Series.ChartArea != null)
{
int num = EnumerableFunctions.IndexOf((IEnumerable)this.Series.ChartArea.GetSeries(), (object)this.Series);
if (num != -1)
{
str = "Series" + num.ToString((IFormatProvider)CultureInfo.InvariantCulture);
}
}
}
return(str);
}
public void Begin()
{
this._runningStoryboards = this.Children.Count;
EnumerableFunctions.ForEachWithIndex <Storyboard>((IEnumerable <Storyboard>) this.Children, (Action <Storyboard, int>)((item, index) =>
{
item.Completed += (EventHandler)((source, args) =>
{
item.Stop();
--this._runningStoryboards;
if (this._runningStoryboards != 0 || this.Completed == null)
{
return;
}
this.Completed((object)this, EventArgs.Empty);
});
item.Begin();
}));
}
internal override void RemoveAllDataPoints()
{
IEnumerable <DataPoint> that = (IEnumerable <DataPoint>) this._dataPointsCollectionShadow;
this._dataPointsByXValue = (OrderedMultipleDictionary <object, DataPoint>)null;
if (that == null)
{
return;
}
if (this.ChartArea != null && this.ChartArea.IsTemplateApplied)
{
EnumerableFunctions.ForEach <DataPoint>(that, (Action <DataPoint>)(item => item.ViewState = DataPointViewState.Hiding));
}
else
{
EnumerableFunctions.ForEach <DataPoint>(that, (Action <DataPoint>)(item => this.UninitializeDataPoint(item)));
}
}
public void ClearSelectedDataPoints()
{
if (!this.HaveSelectedDataPoints)
return;
DataPointSelectionChangedEventArgs e = new DataPointSelectionChangedEventArgs((IList<DataPoint>)Enumerable.ToList<DataPoint>(Enumerable.Where<DataPoint>((IEnumerable<DataPoint>)this.DataPoints, (Func<DataPoint, bool>)(p => p.IsSelected))), (IList<DataPoint>)null);
if (e.RemovedItems.Count <= 0)
return;
try
{
this._clearSelectedDataPointsPerformingFlag = true;
EnumerableFunctions.ForEach<DataPoint>((IEnumerable<DataPoint>)e.RemovedItems, (Action<DataPoint>)(p => p.IsSelected = false));
this.ChartArea.FireDataPointSelectionChanged(e);
}
finally
{
this._clearSelectedDataPointsPerformingFlag = false;
}
}
public virtual void OnSeriesAdded()
{
this.SeriesCollectionChanging = true;
this.ChartArea.ActivateChildModel((FrameworkElement)this.Series);
if (this.ChartArea.IsTemplateApplied)
{
this.ChartArea.UpdateSession.BeginUpdates();
this.Series.SyncDataPoints();
this.UpdateRelatedSeriesPresenters();
this.Series.UpdateSelectedDataPointFlag((DataPoint)null);
this.ChartArea.UpdateSession.ExecuteOnceBeforeUpdating((Action)(() => this.UpdateDataPointVisibility()), (object)new Tuple <Series, string>(this.Series, "__UpdateDataPointVisibility__"));
this.ChartArea.UpdateSession.Update((IUpdatable)this.Series);
bool enableAnimation = this.ChartArea.IsShowingAnimationEnabled;
EnumerableFunctions.ForEach <DataPoint>((IEnumerable <DataPoint>) this.Series.DataPoints, (Action <DataPoint>)(item => this.OnDataPointAdded(item, enableAnimation)));
this.ChartArea.UpdateSession.EndUpdates();
}
this.SeriesCollectionChanging = false;
}
/// <summary>
/// Calculates the length of the data points.
/// </summary>
protected void CalculateDataPointLength()
{
if (!(ActualIndependentAxis is ICategoryAxis))
{
IEnumerable <UnitValue> values =
ActiveDataPoints
.Select(dataPoint => ActualIndependentAxis.GetPlotAreaCoordinate(dataPoint.ActualIndependentValue))
.Where(value => ValueHelper.CanGraph(value.Value))
.OrderBy(value => value.Value)
.ToList();
_dataPointlength =
EnumerableFunctions.Zip(
values,
values.Skip(1),
(left, right) => new Range <double>(left.Value, right.Value))
.Select(range => range.Maximum - range.Minimum)
.MinOrNullable();
}
}
protected override Size MeasureOverride(Size availableSize)
{
this.Populate(this.ElementWidth(availableSize));
double val2 = 0.0;
if (this.Children.Count > 0)
{
Size availableSize1 = new Size(double.PositiveInfinity, double.PositiveInfinity);
foreach (UIElement uiElement in this.Children)
{
uiElement.Measure(availableSize1);
}
val2 = EnumerableFunctions.MaxOrNullable <double>(Enumerable.Select <UIElement, double>(Enumerable.Cast <UIElement>((IEnumerable)this.Children), (Func <UIElement, double>)(child => this.ElementHeight(XYAxisBasePanel.GetDesiredSize(child)) + this.ElementOffset(child)))) ?? 0.0;
}
if (this.Orientation == Orientation.Horizontal)
{
return(new Size(0.0, Math.Max(0.0, val2)));
}
return(new Size(Math.Max(0.0, val2), 0.0));
}
internal virtual void OnAxisScaleChanged(object sender, EventArgs e)
{
Axis axis = sender as Axis;
this.UpdateSession.BeginUpdates();
foreach (XYSeries xySeries in this.Series)
{
XYSeriesPresenter presenter = (XYSeriesPresenter)xySeries.SeriesPresenter;
Action action = (Action)null;
if (axis == xySeries.XAxis)
{
action = (Action)(() => presenter.OnXScaleChanged());
}
else if (axis == xySeries.YAxis)
{
action = (Action)(() => presenter.OnYScaleChanged());
}
if (action != null)
{
if (this.ChartAreaPanel != null && this.ChartAreaPanel.IsDirty)
{
XYChartArea.SeriesAxisKey key = new XYChartArea.SeriesAxisKey()
{
Series = (Semantic.Reporting.Windows.Chart.Internal.Series)xySeries,
Axis = axis
};
if (EnumerableFunctions.FindIndexOf <Tuple <object, Action> >((IEnumerable <Tuple <object, Action> >) this._updateActions, (Func <Tuple <object, Action>, bool>)(t => key.Equals(t.Item1))) == -1)
{
this._updateActions.Enqueue(new Tuple <object, Action>((object)key, action));
}
}
else
{
action();
}
}
}
this.UpdateSession.EndUpdates();
}
protected override void OnSeriesDataPointValueChanged(DataPoint dataPoint, string valueName, object oldValue, object newValue)
{
object obj = (object)null;
bool flag = false;
switch (valueName)
{
case "XValue":
obj = ValueHelper.ConvertValue(oldValue, this.Series.ActualXValueType);
flag = true;
break;
case "YValue":
obj = ValueHelper.ConvertValue(((XYDataPoint)dataPoint).XValue, this.Series.ActualXValueType);
break;
case "YValueInScaleUnits":
if (this.ChartArea != null && this.ChartArea.IsTemplateApplied)
{
obj = ValueHelper.ConvertValue(((XYDataPoint)dataPoint).XValue, this.Series.ActualXValueType);
if (!this._suppressCounterpartInvalidationFlag)
{
EnumerableFunctions.ForEach <XYDataPoint>(Enumerable.Where <XYDataPoint>((IEnumerable <XYDataPoint>) this.GetCounterpartDataPoints(obj, true), (Func <XYDataPoint, bool>)(p => p != dataPoint)), (Action <XYDataPoint>)(p => p.Update()));
break;
}
break;
}
break;
}
if (obj != null && this.ChartArea != null)
{
this.DataPointsByXValueRanges.Remove(obj);
}
if (flag && this.ChartArea != null && (!this.ChartArea.IsDirty && !this.ChartArea.UpdateSession.IsUpdating))
{
this.ChartArea.Invalidate();
}
base.OnSeriesDataPointValueChanged(dataPoint, valueName, oldValue, newValue);
}
protected internal void EnsureAxisMargins()
{
if (!this.IsDirty)
{
return;
}
this.SeriesMarginInfos.Clear();
AxisMargin marginResult = AxisMargin.Empty;
if (this.Axis.Scale != null && this.Axis.Orientation == AxisOrientation.X)
{
EnumerableFunctions.ForEach <KeyValuePair <int, AxisMargin> >(Enumerable.Select <IGrouping <int, Series>, KeyValuePair <int, AxisMargin> >(Enumerable.GroupBy <Series, int>(this.ChartArea.FindSeries(this.Axis), (Func <Series, int>)(series => series.ClusterKey)), (Func <IGrouping <int, Series>, KeyValuePair <int, AxisMargin> >)(seriesGroup => new KeyValuePair <int, AxisMargin>(seriesGroup.Key, ((XYSeriesPresenter)Enumerable.FirstOrDefault <Series>((IEnumerable <Series>)seriesGroup).SeriesPresenter).GetSeriesMarginInfo(this.Axis.IsMarginVisible)))), (Action <KeyValuePair <int, AxisMargin> >)(info => this.SeriesMarginInfos.Add(info.Key, info.Value)));
if (!(this.Axis.Scale is CategoryScale))
{
EnumerableFunctions.ForEach <KeyValuePair <int, AxisMargin> >((IEnumerable <KeyValuePair <int, AxisMargin> >) this.SeriesMarginInfos, (Action <KeyValuePair <int, AxisMargin> >)(info => marginResult = marginResult.Extend(info.Value)));
AxisMargin axisMargin = new AxisMargin(this.Axis.Scale.ProjectedStartMargin, this.Axis.Scale.ProjectedEndMargin);
marginResult = new AxisMargin(Math.Max(0.0, marginResult.Start - axisMargin.Start), Math.Max(0.0, marginResult.End - axisMargin.End));
}
}
this.AggregatedSeriesMargins = new AxisMargin(marginResult.Start * (1.0 - marginResult.Start), marginResult.End * (1.0 - marginResult.End));
this.IsDirty = false;
}
/// <summary>
/// Updates the value and actual value of the rating items.
/// </summary>
private void UpdateDisplayValues()
{
IList <RatingItem> ratingItems = GetRatingItems().ToList();
IEnumerable <Tuple <RatingItem, double> > itemAndWeights =
EnumerableFunctions
.Zip(
ratingItems,
ratingItems
.Select(ratingItem => 1.0)
.GetWeightedValues(WeightedValue),
(item, percent) => Tuple.Create(item, percent));
RatingItem selectedItem = null;
Tuple <RatingItem, double> selectedItemAndWeight = itemAndWeights.LastOrDefault(i => i.Item2 > 0.0);
if (selectedItemAndWeight != null)
{
selectedItem = selectedItemAndWeight.Item1;
}
else
{
selectedItem = GetSelectedRatingItem();
}
foreach (Tuple <RatingItem, double> itemAndWeight in itemAndWeights)
{
if (SelectionMode == RatingSelectionMode.Individual && itemAndWeight.Item1 != selectedItem)
{
itemAndWeight.Item1.DisplayValue = 0.0;
}
else
{
itemAndWeight.Item1.DisplayValue = itemAndWeight.Item2;
}
}
}
internal void LoadDataFromVirtualizer(IEnumerable data)
{
object firstNewDataObject = (object)null;
int num = -1;
if (!EnumerableFunctions.IsEmpty(data))
{
firstNewDataObject = EnumerableFunctions.FastElementAt <object>(data, 0);
if (firstNewDataObject != null)
{
num = EnumerableFunctions.FindIndexOf <DataPoint>((IEnumerable <DataPoint>) this.DataPoints, (Func <DataPoint, bool>)(item =>
{
if (item != firstNewDataObject)
{
return(item.DataContext == firstNewDataObject);
}
return(true);
}));
}
}
if (num < 0)
{
this.ItemsSource = data;
}
else
{
for (; num > 0; --num)
{
this.DataPoints.RemoveAt(0);
}
int index = 0;
foreach (object obj in data)
{
if (index >= 0 && index < this.DataPoints.Count && (this.DataPoints[index] == obj || this.DataPoints[index].DataContext == obj))
{
++index;
}
else
{
if (index >= 0)
{
while (index < this.DataPoints.Count)
{
this.DataPoints.RemoveAt(index);
}
index = -1;
}
DataPoint dataPoint = obj as DataPoint;
if (dataPoint == null || !this.IsDataPointCompatible(dataPoint))
{
dataPoint = this.CreateDataPoint();
dataPoint.DataContext = obj;
if (this.ItemsBinder != null)
{
this.ItemsBinder.Bind(dataPoint, dataPoint.DataContext);
}
}
this.DataPoints.Add(dataPoint);
}
}
}
}
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;
}
}
public int GetChildIndex(object parent, object child)
{
return(EnumerableFunctions.IndexOf((IEnumerable)((Category)parent).Children, child));
}
protected void CreateView(IEnumerable <DataPoint> dataPoints)
{
EnumerableFunctions.ForEachWithIndex <DataPoint>(dataPoints, (Action <DataPoint, int>)((item, index) => this.CreateView(item)));
}
public void Update()
{
EnumerableFunctions.ForEachWithIndex <IUpdatable>(Enumerable.OfType <IUpdatable>((IEnumerable)this.Children), (Action <IUpdatable, int>)((item, index) => item.Update()));
}
public void Stop()
{
EnumerableFunctions.ForEachWithIndex <Storyboard>((IEnumerable <Storyboard>) this.Children, (Action <Storyboard, int>)((item, index) => item.Stop()));
this._runningStoryboards = 0;
}
