protected override float GetCurrentValueCore(float defaultOriginValue, float defaultDestinationValue,
AnimationClock animationClock)
{
throw new NotImplementedException();
}
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue, AnimationClock animationClock)
{
double s = From;
double f = To;
double dist = f - s;
if (dist == 0)
{
parent.velocity = 0;
return(s);
}
double v = velocity / dist;
double x = (double)animationClock.CurrentProgress / 2 + 0.5;
double ease = easeFunc(x, v) - easeFunc(0, v);
//ease = (ease - 0.5) * 2;
double vel = easeVelFunc(x, v);
parent.velocity = vel * dist;
ease = (ease - 0.5) * 2;
return(ease * dist + s);
}
protected override Point GetCurrentValueCore(Point defaultOriginValue, Point defaultDestinationValue, AnimationClock animationClock)
{
Nullable <Point> to = this.To;
Nullable <Point> from = this.From;
if (!from.HasValue)
{
from = defaultOriginValue;
}
if (!to.HasValue)
{
to = defaultDestinationValue;
}
Point toValue = to.GetValueOrDefault();
Point fromValue = from.GetValueOrDefault();
if ((!animationClock.CurrentProgress.HasValue) ||
(animationClock.CurrentProgress.Value == 1))
{
return(toValue);
}
if (animationClock.CurrentProgress.Value == 0)
{
return(fromValue);
}
double totalTime = animationClock.Timeline.Duration.TimeSpan.TotalMilliseconds;
double elapsedTime = totalTime * animationClock.CurrentProgress.Value;
if (elapsedTime >= totalTime)
{
return(toValue);
}
Point animationStep = this.GetAnimationStep(fromValue, toValue, elapsedTime, totalTime);
if (DoubleUtil.AreClose(animationStep.X, toValue.X) && DoubleUtil.AreClose(animationStep.Y, toValue.Y))
{
return(toValue);
}
return(animationStep);
}
public sealed override object GetCurrentValue(object defaultOriginValue,
object defaultDestinationValue, AnimationClock animationClock)
{
if (defaultOriginValue == null)
{
throw new ArgumentNullException("defaultOriginValue");
}
if (defaultDestinationValue == null)
{
throw new ArgumentNullException("defaultDestinationValue");
}
return(this.GetCurrentValue((LinearGradientBrush)defaultOriginValue,
(LinearGradientBrush)defaultDestinationValue, animationClock));
}
/// <summary>
/// Animates the double value
/// </summary>
/// <param name="defaultOriginValue">The original value to animate</param>
/// <param name="defaultDestinationValue">The final value</param>
/// <param name="animationClock">The animation clock (timer)</param>
/// <returns>Returns the new double to set</returns>
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue, AnimationClock animationClock)
{
double fromVal = this.From.Value;
double toVal = this.To.Value;
if (defaultOriginValue == toVal)
{
fromVal = toVal;
toVal = this.ReverseValue.Value;
}
if (fromVal > toVal)
{
return((1 - animationClock.CurrentProgress.Value) *
(fromVal - toVal) + toVal);
}
else
{
return(animationClock.CurrentProgress.Value *
(toVal - fromVal) + fromVal);
}
}
protected abstract CornerRadius GetCurrentValueCore(CornerRadius defaultOriginValue, CornerRadius defaultDestinationValue, AnimationClock animationClock);
protected LinearGradientBrush GetCurrentValueCore(LinearGradientBrush defaultOriginValue, LinearGradientBrush defaultDestinationValue, AnimationClock animationClock)
{
if (!this._isAnimationFunctionValid)
{
this.ValidateAnimationFunction();
}
double num = animationClock.CurrentProgress.Value;
IEasingFunction easingFunction = this.EasingFunction;
if (easingFunction != null)
{
num = easingFunction.Ease(num);
}
LinearGradientBrush brush = null;
LinearGradientBrush brush2 = null;
LinearGradientBrush value = null;
LinearGradientBrush value2 = null;
switch (this._animationType)
{
case AnimationType.Automatic:
brush = defaultOriginValue;
brush2 = defaultDestinationValue;
value = GetDefaultLinearGradientBrush(brush);
value2 = GetDefaultLinearGradientBrush(brush);
break;
case AnimationType.From:
brush = this._keyValues[0];
brush2 = defaultDestinationValue;
value = GetDefaultLinearGradientBrush(brush);
value2 = GetDefaultLinearGradientBrush(brush);
break;
case AnimationType.To:
brush = defaultOriginValue;
brush2 = this._keyValues[0];
value = GetDefaultLinearGradientBrush(brush2);
value2 = GetDefaultLinearGradientBrush(brush2);
break;
case AnimationType.By:
brush2 = this._keyValues[0];
value2 = defaultOriginValue;
value = GetDefaultLinearGradientBrush(brush2);
value2 = GetDefaultLinearGradientBrush(brush2);
break;
case AnimationType.FromTo:
brush = this._keyValues[0];
brush2 = this._keyValues[1];
value = GetDefaultLinearGradientBrush(brush);
value2 = GetDefaultLinearGradientBrush(brush);
if (this.IsAdditive)
{
value2 = defaultOriginValue;
}
break;
case AnimationType.FromBy:
brush = this._keyValues[0];
brush2 = AddLinearGradientBrush(this._keyValues[0], this._keyValues[1]);
value = GetDefaultLinearGradientBrush(brush);
value2 = GetDefaultLinearGradientBrush(brush);
if (this.IsAdditive)
{
value2 = defaultOriginValue;
}
break;
}
if (this.IsCumulative)
{
double num2 = (double)(animationClock.CurrentIteration - 1).Value;
if (num2 > 0.0)
{
LinearGradientBrush value3 = SubtractLinearGradientBrush(brush2, brush);
value = ScaleLinearGradientBrush(value3, num2);
}
}
LinearGradientBrush returnBrush = AddLinearGradientBrush(value2, AddLinearGradientBrush(value, InterpolateGradientBrush(brush, brush2, num)));
return(returnBrush);
}
protected abstract double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue,
AnimationClock animationClock);
/// <summary>
/// DrawLine -
/// Draws a line with the specified pen.
/// Note that this API does not accept a Brush, as there is no area to fill.
/// </summary>
/// <param name="pen"> The Pen with which to stroke the line. </param>
/// <param name="point0"> The start Point for the line. </param>
/// <param name="point0Animations"> Optional AnimationClock for point0. </param>
/// <param name="point1"> The end Point for the line. </param>
/// <param name="point1Animations"> Optional AnimationClock for point1. </param>
public abstract void DrawLine(
Pen pen,
Point point0,
AnimationClock point0Animations,
Point point1,
AnimationClock point1Animations);
/// <summary>
/// This method is called by WPF to implement the actual animation, so this method calculates
/// the exponential value based on how long we've been running so far.
/// </summary>
/// <param name="defaultOriginValue"></param>
/// <param name="defaultDestinationValue"></param>
/// <param name="clock"></param>
/// <returns></returns>
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue, AnimationClock animationClock)
{
double returnValue;
double start = (double)From;
double delta = (double)To - start;
double timeFraction = animationClock.CurrentProgress.Value;
if (timeFraction == 1)
{
return((double)this.To);
}
switch (this.EdgeBehavior)
{
case EdgeBehavior.EaseIn:
returnValue = EaseIn(timeFraction, start, delta, Power);
break;
case EdgeBehavior.EaseOut:
returnValue = EaseOut(timeFraction, start, delta, Power);
break;
case EdgeBehavior.EaseInOut:
default:
returnValue = EaseInOut(timeFraction, start, delta, Power);
break;
}
return(returnValue);
}
/// <summary>
/// PushOpacity -
/// Push an opacity which will blend the composite of all drawing primitives added
/// until the corresponding Pop call.
/// </summary>
/// <param name="opacity">
/// The opacity with which to blend - 0 is transparent, 1 is opaque.
/// </param>
/// <param name="opacityAnimations"> Optional AnimationClock for opacity. </param>
public abstract void PushOpacity(
Double opacity,
AnimationClock opacityAnimations);
/// <summary>
/// DrawVideo -
/// Draw a Video into the region specified by the Rect.
/// The Video will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an VideoBrush via
/// DrawRectangle.
/// </summary>
/// <param name="player"> The MediaPlayer to draw. </param>
/// <param name="rectangle"> The Rect into which the media will be fit. </param>
/// <param name="rectangleAnimations"> Optional AnimationClock for rectangle. </param>
public abstract void DrawVideo(
MediaPlayer player,
Rect rectangle,
AnimationClock rectangleAnimations);
/// <summary>
/// DrawImage -
/// Draw an Image into the region specified by the Rect.
/// The Image will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an ImageBrush via
/// DrawRectangle.
/// </summary>
/// <param name="imageSource"> The ImageSource to draw. </param>
/// <param name="rectangle">
/// The Rect into which the ImageSource will be fit.
/// </param>
/// <param name="rectangleAnimations"> Optional AnimationClock for rectangle. </param>
public abstract void DrawImage(
ImageSource imageSource,
Rect rectangle,
AnimationClock rectangleAnimations);
public override Point?UpdatePosition(VEMap map)
{
if (this.Map != map)
{
map.AddRegisteredPosition(this, DisplayLatLong);
isNewPin = false;
}
base.UpdatePosition(map);
VEPushPinAltitudeEvent altEvent;
bool isVisible;
Point?anchorPosition = GetPosition(DisplayLatLong, out altEvent, out isVisible);
if (isVisible)
{
this.SetValue(VEPushPin.VisibilityProperty, Visibility.Visible);
//If transitioning from invisible
if (currentState != VEPushPinState.Visible &&
currentState != VEPushPinState.FadingIn)
{
OnShow();
AnimationClock showClock = AnimateUtility.AnimateElementDouble(this,
VEPushPin.OpacityProperty,
1,
0,
1);
showClock.Completed += new EventHandler(showClock_Completed);
currentState = VEPushPinState.FadingIn;
//If transitioning and has a parent
if (this.ParentPushPin != null &&
(altEvent == VEPushPinAltitudeEvent.TransitionIntoUpperRange))
{
this.DisplayLatitude = this.ParentPushPin.Latitude;
this.DisplayLongitude = this.ParentPushPin.Longitude;
}
if (this.DisplayLatitude != this.Latitude ||
this.DisplayLongitude != this.Longitude)
{
AnimateUtility.AnimateElementDouble(this,
VEPushPin.DisplayLatitudeProperty,
this.Latitude,
0,
1);
AnimateUtility.AnimateElementDouble(this,
VEPushPin.DisplayLongitudeProperty,
this.Longitude,
0,
1);
anchorPosition = GetPosition(DisplayLatLong);
}
}
}
else
{
//If transitioning from Visible
if (currentState != VEPushPinState.Hidden &&
currentState != VEPushPinState.FadingOut)
{
OnHide();
AnimationClock hideClock = AnimateUtility.AnimateElementDouble(this,
VEPushPin.OpacityProperty,
0,
0,
1);
hideClock.Completed += new EventHandler(hideClock_Completed);
currentState = VEPushPinState.FadingOut;
//If transitioning and has a parent
if (this.ParentPushPin != null &&
(altEvent == VEPushPinAltitudeEvent.TransitionAboveUpperRange))
{
AnimateUtility.AnimateElementDouble(this,
VEPushPin.DisplayLatitudeProperty,
this.ParentPushPin.Latitude,
0,
1);
AnimateUtility.AnimateElementDouble(this,
VEPushPin.DisplayLongitudeProperty,
this.ParentPushPin.Longitude,
0,
1);
anchorPosition = GetPosition(DisplayLatLong);
}
else
{
//Not animating, just hide immediately
//this.Visibility = Visibility.Collapsed;
}
}
}
//Update the calculated position
if (anchorPosition == null || !map.IsMapLoaded)
{
this.Visibility = Visibility.Collapsed;
this.Opacity = 0;
this.currentState = VEPushPinState.Hidden;
return(null);
}
if (!this.IsMeasureValid)
{
this.Opacity = 0;
this.currentState = VEPushPinState.Hidden;
return(null);
}
Point anchorOffset = GetAnchorOffset();
double displayLeft = anchorPosition.Value.X - anchorOffset.X;
double displayTop = anchorPosition.Value.Y - anchorOffset.Y;
return(new Point(displayLeft, displayTop));
}
public LinearGradientBrush GetCurrentValue(LinearGradientBrush defaultOriginValue, LinearGradientBrush defaultDestinationValue, AnimationClock animationClock)
{
base.ReadPreamble();
if (animationClock == null)
{
throw new ArgumentNullException("animationClock");
}
if (animationClock.CurrentState == ClockState.Stopped)
{
return(defaultDestinationValue);
}
return(this.GetCurrentValueCore(defaultOriginValue, defaultDestinationValue, animationClock));
}
public void ApplyAnimationClock(DependencyProperty property, AnimationClock clock)
{
ApplyAnimationClock(property, clock, HandoffBehavior.SnapshotAndReplace);
}
public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock animationClock)
{
double fromVal = ((GridLength)GetValue(GridLengthAnimation.FromProperty)).Value;
double toVal = ((GridLength)GetValue(GridLengthAnimation.ToProperty)).Value;
if (fromVal > toVal)
{
return(new GridLength((1 - animationClock.CurrentProgress.Value) *
(fromVal - toVal) + toVal, GridUnitType.Star));
}
else
{
return(new GridLength(animationClock.CurrentProgress.Value *
(toVal - fromVal) + fromVal, GridUnitType.Star));
}
}
protected override Color GetCurrentValueCore(Color defaultOriginValue, Color defaultDestinationValue, AnimationClock animationClock)
{
System.Diagnostics.Debug.Assert(animationClock.CurrentState != ClockState.Stopped);
if (!_isAnimationFunctionValid)
{
ValidateAnimationFunction();
}
double progress = animationClock.CurrentProgress.Value;
IEasingFunction easingFunction = EasingFunction;
if (easingFunction != null)
{
progress = easingFunction.Ease(progress);
}
double fromVal = _keyvalues[0];
double toVal = _keyvalues[1];
double target;
if (fromVal > toVal)
{
target = (1 - progress) * (fromVal - toVal) + toVal;
}
else
{
target = (toVal - fromVal) * progress + fromVal;
}
Color originColor = OriginColor;
if (target == 0)
{
return(originColor);
}
return(ColorEx.ChangeColorBrightness(originColor, target));
}
public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock animationClock)
{
if (defaultOriginValue is GridLength == false)
{
throw new ArgumentException("Parameter must be a GridLength", "defaultOriginValue");
}
if (defaultDestinationValue is GridLength == false)
{
throw new ArgumentException("Parameter must be a GridLength", "defaultDestinationValue");
}
return(GetCurrentValueCore((GridLength)defaultOriginValue, (GridLength)defaultDestinationValue, animationClock));
}
public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock clock)
{
double from = ((GridLength)GetValue(GAnimation.FromProp)).Value;
double to = ((GridLength)GetValue(GAnimation.ToProp)).Value;
if (from > to)
{
return(new GridLength((from - to) * (1 - clock.CurrentProgress.Value) + to, GridUnitType.Pixel));
}
else
{
return(new GridLength((to - from) * clock.CurrentProgress.Value + from, GridUnitType.Pixel));
}
}
public abstract GridLength GetCurrentValueCore(GridLength defaultOriginValue, GridLength defaultDestinationValue, AnimationClock animationClock);
/// <summary>
/// Work out which type of animation is needed
/// </summary>
/// <param name="defaultOriginValue">default start value</param>
/// <param name="defaultDestinationValue">default end value</param>
/// <param name="animationClock">Animaiton to run</param>
/// <returns></returns>
protected override Point GetCurrentValueCore(Point defaultOriginValue, Point defaultDestinationValue, AnimationClock animationClock)
{
double returnValueX = 0;
double returnValueY = 0;
double time = animationClock.CurrentTime.Value.TotalSeconds;
double startValueX = FromValue.X;
double eqFinalValueX = ToValue.X - FromValue.X;
double startValueY = FromValue.Y;
double eqFinalValueY = ToValue.Y - FromValue.Y;
double duration = Duration.TimeSpan.TotalSeconds;
switch (this.EaseFunction)
{
case PointEasingMode.EaseIn:
returnValueX = eqFinalValueX * (time /= duration) * time + startValueX;
returnValueY = eqFinalValueY * (time /= duration) * time + startValueY;
break;
case PointEasingMode.EaseOut:
returnValueX = -eqFinalValueX * (time /= duration) * (time - 2) + startValueX;
returnValueY = -eqFinalValueY * (time /= duration) * (time - 2) + startValueY;
break;
case PointEasingMode.EaseInOut:
if ((time /= duration / 2) < 1)
{
returnValueX = eqFinalValueX / 2 * time * time + startValueX;
returnValueY = eqFinalValueY / 2 * time * time + startValueY;
}
else
{
returnValueX = -eqFinalValueX / 2 * ((--time) * (time - 2) - 1) + startValueX;
returnValueY = -eqFinalValueY / 2 * ((--time) * (time - 2) - 1) + startValueY;
}
break;
default:
break;
}
return(new Point(returnValueX, returnValueY));
}
public override GridLength GetCurrentValueCore(GridLength defaultOriginValue, GridLength defaultDestinationValue, AnimationClock animationClock)
{
double?from = From;
if (from == null && (defaultOriginValue.IsAbsolute || defaultOriginValue.IsStar))
{
from = defaultOriginValue.Value;
}
if (from == null)
{
throw new Exception("From must be specified in a GridLengthAnimation");
}
double a_to;
if (To != null)
{
a_to = To.Value;
}
else if (By != null)
{
a_to = from.Value + By.Value;
}
else
{
throw new Exception("Either To or By must be specified in a GridLengthAnimation");
}
return(new GridLength(from.Value + ((a_to - from.Value) * animationClock.CurrentProgress.Value)));
}
/// <summary>
/// Calculates a value that represents the current value of the property being animated, as determined by the <see cref="T:System.Windows.Media.Animation.ThicknessAnimation"/>.
/// </summary>
///
/// <returns>
/// The calculated value of the property, as determined by the current animation.
/// </returns>
/// <param name="defaultOriginValue">The suggested origin value, used if the animation does not have its own explicitly set start value.</param><param name="defaultDestinationValue">The suggested destination value, used if the animation does not have its own explicitly set end value.</param><param name="animationClock">An <see cref="T:System.Windows.Media.Animation.AnimationClock"/> that generates the <see cref="P:System.Windows.Media.Animation.Clock.CurrentTime"/> or <see cref="P:System.Windows.Media.Animation.Clock.CurrentProgress"/> used by the animation.</param>
protected override CornerRadius GetCurrentValueCore(CornerRadius defaultOriginValue, CornerRadius defaultDestinationValue, AnimationClock animationClock)
{
if (!this._isAnimationFunctionValid)
{
this.ValidateAnimationFunction();
}
double num1 = animationClock.CurrentProgress.Value;
IEasingFunction easingFunction = this.EasingFunction;
if (easingFunction != null)
{
num1 = easingFunction.Ease(num1);
}
var from = new CornerRadius();
var to = new CornerRadius();
var thickness1 = new CornerRadius();
var thickness2 = new CornerRadius();
bool flag1 = false;
bool flag2 = false;
switch (this._AnimationMode)
{
case AnimationMode.Automatic:
from = defaultOriginValue;
to = defaultDestinationValue;
flag1 = true;
flag2 = true;
break;
case AnimationMode.From:
from = this._keyValues[0];
to = defaultDestinationValue;
flag2 = true;
break;
case AnimationMode.To:
from = defaultOriginValue;
to = this._keyValues[0];
flag1 = true;
break;
case AnimationMode.By:
to = this._keyValues[0];
thickness2 = defaultOriginValue;
flag1 = true;
break;
case AnimationMode.FromTo:
from = this._keyValues[0];
to = this._keyValues[1];
if (this.IsAdditive)
{
thickness2 = defaultOriginValue;
flag1 = true;
break;
}
break;
case AnimationMode.FromBy:
from = this._keyValues[0];
to = AnimationHelpers.AddCornerRadius(this._keyValues[0], this._keyValues[1]);
if (this.IsAdditive)
{
thickness2 = defaultOriginValue;
flag1 = true;
break;
}
break;
}
if (flag1 && !AnimationHelpers.IsValidAnimationValueCornerRadius(defaultOriginValue))
{
throw new InvalidOperationException("Animation_Invalid_DefaultValue");
}
if (flag2 && !AnimationHelpers.IsValidAnimationValueCornerRadius(defaultDestinationValue))
{
throw new InvalidOperationException("Animation_Invalid_DefaultValue");
}
if (this.IsCumulative)
{
int? currentIteration = animationClock.CurrentIteration;
int num2 = 1;
double factor = (double)(currentIteration.HasValue ? new int?(currentIteration.GetValueOrDefault() - num2) : new int?()).Value;
if (factor > 0.0)
{
thickness1 = AnimationHelpers.ScaleCornerRadius(AnimationHelpers.SubtractCornerRadius(to, from), factor);
}
}
return(AnimationHelpers.AddCornerRadius(thickness2, AnimationHelpers.AddCornerRadius(thickness1, AnimationHelpers.InterpolateCornerRadius(from, to, num1))));
}
public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock animationClock)
{
return(this.GetCurrentValue(defaultOriginValue as Brush, defaultDestinationValue as Brush, animationClock));
}
protected abstract LinearGradientBrush GetCurrentValueCore(LinearGradientBrush
defaultOriginValue, LinearGradientBrush defaultDestinationValue,
AnimationClock animationClock);
public object GetCurrentValue(Brush defaultOriginValue, Brush defaultDestinationValue, AnimationClock animationClock)
{
if (!animationClock.CurrentProgress.HasValue)
{
return(Brushes.Transparent);
}
//use the standard values if From and To are not set
//(it is the value of the given property)
defaultOriginValue = this.From ?? defaultOriginValue;
defaultDestinationValue = this.To ?? defaultDestinationValue;
if (animationClock.CurrentProgress.Value == 0)
{
return(defaultOriginValue);
}
if (animationClock.CurrentProgress.Value == 1)
{
return(defaultDestinationValue);
}
return(new VisualBrush(new Border {
Width = 1, Height = 1, Background = defaultOriginValue, Child = new Border {
Background = defaultDestinationValue, Opacity = animationClock.CurrentProgress.Value
}
}));
}
public double GetCurrentValueCorePublic(double defaultOriginValue, double defaultDestinationValue, AnimationClock animationClock) => GetCurrentValueCore(defaultOriginValue, defaultDestinationValue, animationClock);
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue, AnimationClock clock)
{
double returnValue;
double start = From != null ? (double)From : defaultOriginValue;
double delta = To != null ? (double)To - start : defaultOriginValue - start;
switch (this.EdgeBehavior)
{
case EdgeBehaviorEnum.EaseIn:
returnValue = easeIn(clock.CurrentProgress.Value, start, delta, Power);
break;
case EdgeBehaviorEnum.EaseOut:
returnValue = easeOut(clock.CurrentProgress.Value, start, delta, Power);
break;
case EdgeBehaviorEnum.EaseInOut:
default:
returnValue = easeInOut(clock.CurrentProgress.Value, start, delta, Power);
break;
}
return(returnValue);
}
/// <summary>
/// returns the current size value for a given time between <see cref="From"/> and <see cref="To"/>
/// </summary>
/// <param name="defaultOriginValue">start size value</param>
/// <param name="defaultDestinationValue">end size value</param>
/// <param name="animationClock">describes the current time</param>
/// <returns></returns>
public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock animationClock)
{
double fromValue = From.Value;
double toValue = To.Value;
if (fromValue > toValue)
{
return(new GridLength((1 - animationClock.CurrentProgress.Value) * (fromValue - toValue) + toValue, GridUnitType.Pixel));
}
else
{
return(new GridLength(animationClock.CurrentProgress.Value * (toValue - fromValue) + fromValue, GridUnitType.Pixel));
}
}
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue, AnimationClock clock)
{
double returnValue;
double time = clock.CurrentProgress.Value;
// math magic: calculate new coordinates using polar coordinate equations. This requires two
// animations to be wired up in order to move in a circle, since we don't make any assumptions
// about what we're animating (e.g. a TranslateTransform).
if (Direction == DirectionEnum.XDirection)
{
returnValue = Math.Cos(2 * Math.PI * time);
}
else
{
returnValue = Math.Sin(2 * Math.PI * time);
}
// Need to add the defaultOriginValue so that composition works.
return(returnValue * Radius + defaultOriginValue);
}
protected override double GetCurrentValueCore(double defaultOriginValue, double defaultDestinationValue,
AnimationClock animationClock)
{
throw new NotImplementedException();
}
void Start()
{
Stop();
m_clock = s_animationClock.CreateClock();
ApplyAnimationClock(AnimationClockProperty, m_clock);
}
public void ApplyAnimationClock(DependencyProperty property, AnimationClock clock, HandoffBehavior handoffBehavior) {}
public double GetCurrentValue(double defaultOriginValue, double defaultDestinationValue,
AnimationClock animationClock)
{
return GetCurrentValueCore(defaultOriginValue, defaultDestinationValue, animationClock);
}
