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