public static Storyboard CreateAnimation(this DependencyObject target, Dictionary <string, StoryboardInfo> storyboards, DependencyProperty animatingDependencyProperty, string propertyPath, string propertyKey, object initialValue, object targetValue, TimeSpan timeSpan, IEasingFunction easingFunction, Action releaseAction) { StoryboardInfo storyboardInfo; storyboards.TryGetValue(DependencyPropertyAnimationHelper.GetStoryboardKey(propertyKey), out storyboardInfo); if (storyboardInfo != null) { DependencyObject storyboardTarget = storyboardInfo.StoryboardTarget; storyboardInfo.Storyboard.Stop(); storyboards.Remove(DependencyPropertyAnimationHelper.GetStoryboardKey(propertyKey)); if (storyboardInfo.ReleaseAction != null) { storyboardInfo.ReleaseAction(); storyboardInfo.ReleaseAction = (Action)null; } } storyboardInfo = new StoryboardInfo(); storyboardInfo.Storyboard = DependencyPropertyAnimationHelper.CreateStoryboard(target, animatingDependencyProperty, propertyPath, propertyKey, ref targetValue, timeSpan, easingFunction); storyboardInfo.ReleaseAction = releaseAction; storyboardInfo.StoryboardTarget = target; storyboardInfo.AnimateFrom = initialValue; storyboardInfo.Storyboard.Completed += (EventHandler)((source, args) => { storyboards.Remove(DependencyPropertyAnimationHelper.GetStoryboardKey(propertyKey)); if (storyboardInfo.ReleaseAction == null) { return; } storyboardInfo.ReleaseAction(); storyboardInfo.ReleaseAction = (Action)null; }); storyboards.Add(DependencyPropertyAnimationHelper.GetStoryboardKey(propertyKey), storyboardInfo); return(storyboardInfo.Storyboard); }
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 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(); }
public static void BeginAnimation(ChartArea seriesHost, string propertyName, object currentValue, object targetValue, Action <object, object> propertyUpdateAction, Dictionary <string, StoryboardInfo> storyboards, TimeSpan timeSpan, IEasingFunction easingFunction) { if (timeSpan == TimeSpan.Zero) { propertyUpdateAction(currentValue, targetValue); } else { DependencyPropertyAnimationHelper.CreateAnimation(seriesHost, propertyName, currentValue, targetValue, propertyUpdateAction, storyboards, timeSpan, easingFunction).Begin(); } }
internal virtual void OnXScaleChanged() { DateTime now = DateTime.Now; if (this.ChartArea == null) { return; } this.ChartArea.UpdateSession.BeginUpdates(); bool flag = true; foreach (XYDataPoint xyDataPoint in (Collection <DataPoint>) this.Series.DataPoints) { xyDataPoint.XValueInScaleUnitsWithoutAnimation = this.Series.XAxis.Scale.ProjectDataValue(xyDataPoint.XValue); string storyboardKey = DependencyPropertyAnimationHelper.GetStoryboardKey("XValueInScaleUnits"); StoryboardInfo si = (StoryboardInfo)null; if (xyDataPoint.Storyboards.TryGetValue(storyboardKey, out si) && si.Storyboard.Children.Count > 0) { DoubleAnimation doubleAnimation = si.Storyboard.Children[0] as DoubleAnimation; if (doubleAnimation != null && xyDataPoint.XValue != null) { double?to = doubleAnimation.To; double xvalueInScaleUnits = xyDataPoint.XValueInScaleUnits; if ((to.GetValueOrDefault() != xvalueInScaleUnits ? 1 : (!to.HasValue ? 1 : 0)) != 0) { if (!this.IsAnimationDirectionChanged(si, doubleAnimation.To.Value, xyDataPoint.XValueInScaleUnitsWithoutAnimation)) { flag = false; } doubleAnimation.To = new double?(xyDataPoint.XValueInScaleUnitsWithoutAnimation); continue; } } } xyDataPoint.XValueInScaleUnits = xyDataPoint.XValueInScaleUnitsWithoutAnimation; } if (!flag) { foreach (XYDataPoint dataPoint in (Collection <DataPoint>) this.Series.DataPoints) { this.SkipToFillValueAnimation(dataPoint, "XValueInScaleUnits"); } } if (this.Series.LabelVisibility == Visibility.Visible) { LabelVisibilityManager manager = this.LabelVisibilityManager; manager.InvalidateXIntervals(); this.ChartArea.UpdateSession.ExecuteOnceAfterUpdating((Action)(() => manager.UpdateDataPointLabelVisibility()), (object)"LabelVisibilityManager_UpdateDataPointLabelVisibility", (string)null); } this.ChartArea.UpdateSession.EndUpdates(); }
public static Storyboard CreateAnimation(ChartArea seriesHost, string propertyName, object currentValue, object targetValue, Action <object, object> propertyUpdateAction, Dictionary <string, StoryboardInfo> storyboards, TimeSpan timeSpan, IEasingFunction easingFunction) { ObjectPool <PropertyAnimator, object> propertyAnimatorPool = (ObjectPool <PropertyAnimator, object>)seriesHost.SingletonRegistry.GetSingleton((object)"__PropertyAnimatorPool__", (Func <object>)(() => (object)new ObjectPool <PropertyAnimator, object>((Func <PropertyAnimator>)(() => new PropertyAnimator()), (Action <PropertyAnimator, object>)((obj, context) => obj.AnimatedValue = context), (Action <PropertyAnimator>)(obj => obj.UpdateAction = (Action <object, object>)null))), (Action <object>)(obj => ((ObjectPool <PropertyAnimator, object>)obj).ReleaseAll())); PropertyAnimator propertyAnimator = propertyAnimatorPool.Get(currentValue); propertyAnimator.UpdateAction = propertyUpdateAction; Action releaseAction = (Action)(() => { propertyAnimatorPool.Release(propertyAnimator); propertyAnimatorPool.AdjustPoolSize(); }); return(DependencyPropertyAnimationHelper.CreateAnimation((DependencyObject)propertyAnimator, storyboards, PropertyAnimator.AnimatedValueProperty, "AnimatedValue", propertyName, currentValue, targetValue, timeSpan, easingFunction, releaseAction)); }
private void UpdateActualDataPointOpacity() { double opacity = this.Opacity; double num = this.Series == null || !this.Series.IsDataPointAppearsUnselected(this) ? (this.Series == null ? this.Opacity : Math.Min(this.Series.Opacity, this.Opacity)) : Math.Min(this.Series.UnselectedDataPointOpacity, this.UnselectedOpacity); string storyboardKey = DependencyPropertyAnimationHelper.GetStoryboardKey("ActualOpacity"); StoryboardInfo storyboardInfo = (StoryboardInfo)null; if (this.Storyboards.TryGetValue(storyboardKey, out storyboardInfo) && storyboardInfo.Storyboard.Children.Count > 0) { DoubleAnimation doubleAnimation = storyboardInfo.Storyboard.Children[0] as DoubleAnimation; if (doubleAnimation != null) { doubleAnimation.To = new double?(num); return; } } this.ActualOpacity = num; }
public static void SetValueWithAnimation(this DataPoint dataPoint, DependencyProperty dp, string propertyName, double value) { double num = (double)dataPoint.GetValue(dp); if (num == value) { return; } Series series = dataPoint.Series; if (series == null || series.ChartArea == null || (DoubleHelper.IsNaN(num) || DoubleHelper.IsNaN(value))) { dataPoint.SetValue(dp, (object)value); } else { DependencyPropertyAnimationHelper.BeginAnimation(series.ChartArea, propertyName, (object)num, (object)value, (Action <object, object>)((current, next) => dataPoint.SetValue(dp, next)), dataPoint.Storyboards, series.ActualTransitionDuration, series.ActualTransitionEasingFunction); } }
internal void UpdateAllDataPointsSize() { foreach (BubbleDataPoint bubbleDataPoint in (Collection <DataPoint>) this.DataPoints) { if (bubbleDataPoint.IsSizeValueUsed) { bubbleDataPoint.SizeValueInScaleUnitsWithoutAnimation = bubbleDataPoint.SizeValue == null ? 0.0 : ((BubbleSeriesPresenter)this.SeriesPresenter).ProjectSizeToPixels((DataPoint)bubbleDataPoint, ValueHelper.ToDouble(bubbleDataPoint.SizeValue)); string storyboardKey = DependencyPropertyAnimationHelper.GetStoryboardKey("SizeValueInScaleUnits"); StoryboardInfo storyboardInfo = (StoryboardInfo)null; if (bubbleDataPoint.Storyboards.TryGetValue(storyboardKey, out storyboardInfo) && storyboardInfo.Storyboard.Children.Count > 0) { DoubleAnimation doubleAnimation = storyboardInfo.Storyboard.Children[0] as DoubleAnimation; if (doubleAnimation != null) { doubleAnimation.To = new double?(bubbleDataPoint.SizeValueInScaleUnitsWithoutAnimation); continue; } } bubbleDataPoint.SizeValueInScaleUnits = bubbleDataPoint.SizeValueInScaleUnitsWithoutAnimation; } } }
protected override bool StartDataPointShowingAnimation(DataPoint dataPoint) { StoryboardGroup storyboardGroup = new StoryboardGroup(); if (!this.IsSeriesAnimationEnabled || (IAppearanceProvider)dataPoint == null) { return(false); } double actualOpacity = dataPoint.ActualOpacity; dataPoint.ActualOpacity = 0.0; storyboardGroup.Children.Add(DependencyPropertyAnimationHelper.CreateAnimation(this.ChartArea, "ActualOpacity", (object)0.0, (object)actualOpacity, (Action <object, object>)((value1, value2) => dataPoint.ActualOpacity = (double)value2), dataPoint.Storyboards, this.Series.ActualTransitionDuration, this.Series.ActualTransitionEasingFunction)); storyboardGroup.Completed += (EventHandler)((source, args) => { if (dataPoint.ViewState != DataPointViewState.Showing) { return; } dataPoint.ViewState = DataPointViewState.Normal; }); storyboardGroup.Begin(); return(true); }
private void ChangeDataPointSizeValue(BubbleDataPoint dataPoint, object newValue) { if (dataPoint == null) { return; } double valueInScaleUnits = dataPoint.SizeValueInScaleUnits; double num = this.ProjectSizeToPixels((DataPoint)dataPoint, ValueHelper.ToDouble(newValue)); dataPoint.SizeValueInScaleUnitsWithoutAnimation = num; if (valueInScaleUnits == num) { return; } if (ValueHelper.CanGraph(valueInScaleUnits) && ValueHelper.CanGraph(num) && (this.IsSeriesAnimationEnabled && this.ChartArea != null)) { DependencyPropertyAnimationHelper.BeginAnimation(this.ChartArea, "SizeValueInScaleUnits", (object)valueInScaleUnits, (object)num, (Action <object, object>)((value1, value2) => dataPoint.SizeValueInScaleUnits = (double)value2), dataPoint.Storyboards, this.Series.ActualTransitionDuration, this.Series.ActualTransitionEasingFunction); } else { this.SkipToFillValueAnimation((XYDataPoint)dataPoint, "SizeValueInScaleUnits"); dataPoint.SizeValueInScaleUnits = num; } }