/// <summary>Creates a new animated property.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="property">The property being animated.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public AnimatedProperty(UIAnimation animation,CssProperty property,int innerIndex,Css.Value targetValue,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor,bool updateCss){ Animation=animation; PropertyInfo=property; InnerIndex=innerIndex; Css.ValueType type=targetValue.Type; if(!Animation.ElementStyle.Properties.TryGetValue(property,out ValueObject)){ ComputedStyle computed=Animation.ElementStyle.Computed; if(computed!=null && computed.Properties.TryGetValue(property,out ValueObject)){ // Let's derive from the computed form. ValueObject=ValueObject.Copy(); }else{ ValueObject=new Css.Value(); if(innerIndex!=-1 || type==Css.ValueType.Null){ type=Css.ValueType.Rectangle; } property.SetDefault(ValueObject,type); } Animation.ElementStyle.Properties[property]=ValueObject; } if(ValueObject.Type==Css.ValueType.Inherit){ // Special case - we need to duplicate it. Animation.ElementStyle.Properties[property]=ValueObject=ValueObject.Copy(); ValueObject.Type=type; } PropertyValueObject=ValueObject; if(innerIndex!=-1){ Css.Value innerValue=ValueObject[innerIndex]; if(innerValue==null){ ValueObject[innerIndex]=innerValue=new Css.Value(); } ValueObject=innerValue; } // Set our starting value: ActiveValue=ValueObject.ToFloat(); Animate(Animation,targetValue,constantSpeedTime,timeToAccelerateFor,timeToDecelerateFor,updateCss); }
/// <summary>Animates this property now.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="targetValue">The parsed value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public void Animate(UIAnimation animation,Css.Value targetValue,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor,bool updateCss){ Animation=animation; ValueObject.Type=targetValue.Type; Stage=0; Speed=0f; CurrentTime=0f; UpdateCss=updateCss; PropertyAfter=PropertyBefore=null; // Find the max speed. This is what we accelerate to. // Speed (y) / time (x) graph: // /| |-| |\ // A B C. A = accelerate, b=constant, c=decelerate. // Max speed = top y value. // Distance travelled = area of the graph. This should match target - current value. TargetValue=targetValue.ToFloat(); float unitsDelta=TargetValue - ActiveValue; MaxSpeed=(unitsDelta*UI.RedrawRate) / ( (0.5f*timeToAccelerateFor) + constantSpeedTime + (0.5f*timeToDecelerateFor) ); if(timeToAccelerateFor==0f){ // Skip acceleration stage. Stage=1; Speed=MaxSpeed; }else{ Acceleration=MaxSpeed*UI.RedrawRate / timeToAccelerateFor; } if(timeToDecelerateFor!=0f){ Deceleration=MaxSpeed*UI.RedrawRate / timeToDecelerateFor; } }
/// <summary>Animates this property now.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public void Animate(UIAnimation animation,string targetValue,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor,bool updateCss){ // Get the target float value for calculating our transition speeds as an object: Css.Value targetValueObject=new Css.Value(); targetValueObject.Set(targetValue); Animate(animation,targetValueObject,constantSpeedTime,timeToAccelerateFor,timeToDecelerateFor,updateCss); }