public void ApplyValue(RadObject element) { this.RemovePreviousAnimation(element); if (!this.IsAnimationEnabled(element)) { this.OnAnimationStarted(new AnimationStatusEventArgs(element, false)); this.OnAnimationFinished(new AnimationStatusEventArgs(element, true, !this.RemoveAfterApply)); } else { ElementValuesAnimator animator = this.GetAnimator(element); animator.Initialize(element, this.startValue != null ? this.startValue : element.GetValue(this.Property)); if (this.RandomDelay != 0) { this.ApplyDelay = AnimatedPropertySetting.rand.Next(this.RandomDelay); } if (this.ApplyDelay > 0) { animator.Waiting = true; Timer timer = new Timer(); timer.Interval = this.ApplyDelay; timer.Tick += new EventHandler(this.delayTimer_Tick); timer.Tag = (object)element; timer.Start(); } else { this.OnAnimationStarted(new AnimationStatusEventArgs(element, false)); animator.Start(element); } } }
public override void ApplyValue(RadElement element) { if (this.ApplyDelay > 0) { //we have an initial delay that we should reflect Timer timer = new Timer(); timer.Interval = this.ApplyDelay; timer.Tick += new EventHandler(delayTimer_Tick); timer.Tag = element; delayTimerForElement[element.GetHashCode()] = timer; timer.Start(); object animatedValue = this.StartValue; if (animatedValue != null) { ElementValuesAnimator animator = this.GetAnimator(element); animator.SetCurrentValue(animatedValue); this.OnAnimationStarted(new AnimationStatusEventArgs(element, false)); } } else { ApplyValueInternal(element); } }
private ElementValuesAnimator CreateAnimator(RadElement element) { ElementValuesAnimator result = new ElementValuesAnimator(element, this); element.ValuesAnimators.Add(this.GetHashCode(), result); return(result); }
protected override void PropertySettingRemoving(RadObject targetRadObject) { ElementValuesAnimator animator = ((RadElement)targetRadObject).ValuesAnimators[this.GetHashCode()] as ElementValuesAnimator; if (animator != null) { animator.SettingRemoving(); } }
public bool IsAnimating(RadObject element) { ElementValuesAnimator valuesAnimator = element.ValuesAnimators[(object)this.GetHashCode()] as ElementValuesAnimator; if (valuesAnimator != null) { return(valuesAnimator.IsRunning); } return(false); }
private ElementValuesAnimator GetAnimator(RadObject element) { ElementValuesAnimator elementValuesAnimator = element.ValuesAnimators[(object)this.GetHashCode()] as ElementValuesAnimator; if (elementValuesAnimator == null) { elementValuesAnimator = new ElementValuesAnimator(element, this); element.ValuesAnimators.Add((object)this.GetHashCode(), (object)elementValuesAnimator); } return(elementValuesAnimator); }
private ElementValuesAnimator GetAnimator(RadElement element) { ElementValuesAnimator result = element.ValuesAnimators[this.GetHashCode()] as ElementValuesAnimator; if (result == null) { result = CreateAnimator(element); } return(result); }
internal void RemovePreviousAnimation(RadElement element, AnimatedPropertySetting setting) { // Evtim: Added code to throw OnAnimationFinished when animation is changed with another one ElementValuesAnimator prevAnimator = setting != null?setting.GetExistingAnimator(element) : null; if (prevAnimator != null && prevAnimator.IsRunning) { setting.PropertySettingRemoving(element); setting.OnAnimationFinished(new AnimationStatusEventArgs(element, true, false)); } }
public override void UnregisterValue(RadElement element) { int key = this.GetHashCode(); ElementValuesAnimator animator = element.ValuesAnimators[key] as ElementValuesAnimator; if (animator != null) { animator.Stop(); element.ValuesAnimators.Remove(key); } this.OnAnimationFinished(new AnimationStatusEventArgs(element, false, true)); }
private void StopAnimation(RadObject element, bool cancel) { ElementValuesAnimator valuesAnimator = element.ValuesAnimators[(object)this.GetHashCode()] as ElementValuesAnimator; if (valuesAnimator == null || !valuesAnimator.Waiting && !valuesAnimator.IsRunning) { return; } valuesAnimator.Stop(); if (!cancel) { valuesAnimator.Value = this.GetEndValue(element); } this.OnAnimationFinished(new AnimationStatusEventArgs(element, true, !cancel && !this.RemoveAfterApply)); }
public override void UnapplyValue(RadElement element) { if (this.IsAnimationEnabled(element) && (this.AnimatorStyle & AnimatorStyles.AnimateWhenUnapply) == AnimatorStyles.AnimateWhenUnapply) { //Undo animation only if already aplied ElementValuesAnimator animator = element.ValuesAnimators[this.GetHashCode()] as ElementValuesAnimator; if (animator != null) { animator.Start(AnimationState.Reversing); } } else { OnAnimationFinished(new AnimationStatusEventArgs(element, false, false)); } }
public void Stop(RadElement element) { if (this.RemoveDelayTimer(element)) { this.OnAnimationFinished(new AnimationStatusEventArgs(element, true, true)); } else { ElementValuesAnimator animator = this.GetExistingAnimator(element); if (animator != null && animator.IsRunning) { animator.Stop(); this.OnAnimationFinished(new AnimationStatusEventArgs(element, true, true)); } } }
private void RemovePreviousAnimation(RadObject element) { AnimatedPropertySetting currentAnimation = element.GetCurrentAnimation(this.Property); if (currentAnimation == null) { return; } ElementValuesAnimator valuesAnimator = element.ValuesAnimators[(object)currentAnimation.GetHashCode()] as ElementValuesAnimator; if (valuesAnimator == null || !valuesAnimator.IsRunning) { return; } valuesAnimator.Stop(); currentAnimation.OnAnimationFinished(new AnimationStatusEventArgs(element, true, false)); }
private void ApplyValueInternal(RadElement element) { RemovePreviousAnimation(element, this.GetAnimatedSetting(element)); ElementValuesAnimator animator = this.GetAnimator(element); animator.ReInitialize(element, this.GetInitialValue(element)); //notify attached element for animation start event if (this.applyDelay <= 0) { this.OnAnimationStarted(new AnimationStatusEventArgs(element, false)); } if (this.IsAnimationEnabled(element) && (this.AnimatorStyle & AnimatorStyles.AnimateWhenApply) == AnimatorStyles.AnimateWhenApply && element.Visibility == ElementVisibility.Visible && element.ElementTree != null && element.ElementTree.Control.Visible) { animator.Start(AnimationState.Applying); return; } //we should animate the value, simply calculate the EndValue and apply it to the element. AnimationValueCalculator calculator = AnimationValueCalculatorFactory.GetCalculator(this.Property.PropertyType); object animatedValue; if (this.EndValue == null) { animatedValue = this.StartValue; if (animatedValue == null) { animatedValue = animator.CachedStartValue; } for (int i = 1; i <= this.NumFrames; i++) { animatedValue = calculator.CalculateAnimatedValue(this.StartValue, this.EndValue, animatedValue, this.Step, i, this.NumFrames, new StandardEasingCalculator(RadEasingType.InQuad)); } } else { animatedValue = this.EndValue; } animator.SetCurrentValue(animatedValue); //notify for the value change this.OnValueApplied(element); }
private void delayTimer_Tick(object sender, EventArgs e) { Timer timer = (Timer)sender; RadObject tag = (RadObject)timer.Tag; timer.Tick -= new EventHandler(this.delayTimer_Tick); timer.Stop(); timer.Dispose(); ElementValuesAnimator valuesAnimator = tag.ValuesAnimators[(object)this.GetHashCode()] as ElementValuesAnimator; if (valuesAnimator == null) { return; } valuesAnimator.Waiting = false; this.OnAnimationStarted(new AnimationStatusEventArgs(tag, false)); valuesAnimator.Start(tag); }
public object GetCurrentValue(RadObject radObject) { if (!this.IsAnimationEnabled(radObject)) { return(this.GetEndValue(radObject)); } ElementValuesAnimator valuesAnimator = radObject.ValuesAnimators[(object)this.GetHashCode()] as ElementValuesAnimator; if (valuesAnimator == null) { return(this.endValue); } object obj = valuesAnimator.Value; if (this.ApplyEasingType == RadEasingType.OutElastic && obj != null && (this.maxValue != null && Convert.ToDouble(obj) > Convert.ToDouble(this.maxValue))) { return(this.maxValue); } return(obj); }
public void AppendValue( RadObject element, RadProperty property, object startValue, object endValue, int frames, int interval) { if (this.Property != property) { return; } this.StartValue = startValue; this.EndValue = endValue; this.NumFrames = frames; this.Interval = interval; ElementValuesAnimator animator = this.GetAnimator(element); animator.Stop(); animator.Initialize(element, this.StartValue); animator.Start(element); }
public ValuesAnimatorApplyingState(ElementValuesAnimator animator) : base(animator) { }
/// <summary> /// Creates an instance of the <see cref="ValuesAnimatorState"/> class. /// </summary> /// <param name="animator"></param> public ValuesAnimatorState(ElementValuesAnimator animator) { this.animator = animator; }
public ValuesAnimatorReversingState(ElementValuesAnimator animator) : base(animator) { }
public override object GetCurrentValue(RadObject forObject) { ElementValuesAnimator animator = this.GetAnimator((RadElement)forObject); return(animator.GetCurrentValue()); }
public ValuesAnimatorNotRunningState(ElementValuesAnimator animator) : base(animator) { }
public bool IsAnimating(RadElement element) { ElementValuesAnimator animator = GetExistingAnimator(element); return(animator != null ? animator.IsRunning : false); }