/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
PlaneProjection projection = info.Target.Projection as PlaneProjection;
if (projection == null)
{
return;
}
double direction = this.Direction == PerspectiveAnimationDirection.Clockwise ? -1 : 1;
double rotation;
PerspectiveAnimationAxis axes = this.Axes;
bool autoReverse = this.GetAutoReverse();
if ((axes & PerspectiveAnimationAxis.X) == PerspectiveAnimationAxis.X)
{
rotation = autoReverse ? this.StartAngleX : this.EndAngleX;
projection.RotationX = rotation * direction;
}
if ((axes & PerspectiveAnimationAxis.Y) == PerspectiveAnimationAxis.Y)
{
rotation = autoReverse ? this.StartAngleY : this.EndAngleY;
projection.RotationY = rotation * direction;
}
if ((axes & PerspectiveAnimationAxis.Z) == PerspectiveAnimationAxis.Z)
{
rotation = autoReverse ? this.StartAngleZ : this.EndAngleZ;
projection.RotationZ = rotation * direction;
}
}
private static bool PlayCore(PlayAnimationInfo animationInfo, Action completeCallback, params object[] args)
{
if (!CanAnimate(animationInfo.Target))
{
BeginInvokeCallback(completeCallback, animationInfo.Target);
return(false);
}
Storyboard storyboard = animationInfo.Storyboard;
// associate the animation info with the storyboard
storyboard.SetValue(AnimationInfoProperty, animationInfo);
storyboard.Completed += OnStoryboardCompleted;
if (completeCallback != null)
{
AddCallback(storyboard, completeCallback);
}
animationInfo.Animation.UpdateAnimation(animationInfo.Target, storyboard, args);
storyboard.Begin();
animationInfo.Animation.OnStarted(animationInfo);
return(true);
}
/// <summary>
/// Plays the provides animation on the specified target.
/// </summary>
/// <param name="target">The <see cref="T:System.Windows.UIElement"/> instance to be animated.</param>
/// <param name="animation">The <see cref="RadAnimation"/> instance that describes the animation process.</param>
/// <param name="completedCallback">Optional callback to notify the caller for animation completion.</param>
/// <returns>True if the animation has been successfully executed, false otherwise.</returns>
public static bool Play(UIElement target, RadAnimation animation, Action completedCallback)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (animation == null)
{
throw new ArgumentNullException("animation");
}
PlayAnimationInfo info = GetAnimationInfo(arg => arg.Target == target && arg.Animation == animation);
if (info != null)
{
StopStoryboard(info);
}
Storyboard storyboard = animation.CreateStoryboard(target);
info = CreatePlayAnimationInfo(target, animation, storyboard);
return(PlayCore(info, completedCallback));
}
/// <summary>
/// Called by the animation manager before an associated storyboard is stopped.
/// Allows inheritors to store any animated values to be restored later, when the storyboard is already stopped.
/// </summary>
/// <param name="info">The info.</param>
internal void OnStopping(PlayAnimationInfo info)
{
if (this.FillBehavior != AnimationFillBehavior.Stop && info.Target != null)
{
this.CopyAnimationValues(info);
}
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
UIElement target = info.Target;
double height = this.GetAutoReverse() ? GetHeight(target, this.StartHeight) : GetHeight(target, this.EndHeight);
target.SetValue(FrameworkElement.HeightProperty, height);
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
double endY = 0;
FrameworkElement target = info.Target as FrameworkElement;
if (this.GetAutoReverse())
{
if (this.PointMode == MoveAnimationPointMode.Absolute)
{
endY = GetY(target, this.StartY);
}
else
{
endY = GetRelativeY(target, this.StartY);
}
}
else
{
if (this.PointMode == MoveAnimationPointMode.Absolute)
{
endY = GetY(target, this.EndY);
}
else
{
endY = GetRelativeY(target, this.EndY);
}
}
target.GetTranslateTransform().Y = endY;
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
foreach (RadAnimation animation in this.Children)
{
animation.ApplyAnimationValues(info);
}
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
UIElement target = info.Target;
double width = this.GetAutoReverse() ? GetWidth(target, this.StartWidth) : GetWidth(target, this.EndWidth);
target.SetValue(FrameworkElement.WidthProperty, width);
}
private static void OnStoryboardCompleted(object sender, object e)
{
Storyboard storyboard = sender as Storyboard;
PlayAnimationInfo info = storyboard.GetValue(AnimationInfoProperty) as PlayAnimationInfo;
Debug.Assert(info != null, "Must have PlayAnimationInfo associated.");
StopStoryboard(info);
}
/// <summary>
/// Called by the animation manager after an associated storyboard has been stopped.
/// Allows inheritors to apply previously stored (if any) animated values.
/// </summary>
/// <param name="info">The info.</param>
internal void OnStopped(PlayAnimationInfo info)
{
if (this.FillBehavior != AnimationFillBehavior.Stop && info.Target != null)
{
this.ApplyAnimationValues(info);
}
this.OnEnded(info);
}
/// <summary>
/// Fires the <see cref="RadAnimation.Ended" /> event for the specific target provided
/// in the <see cref="PlayAnimationInfo" /> object.
/// </summary>
/// <param name="info">The info.</param>
protected virtual void OnEnded(PlayAnimationInfo info)
{
if (this.Ended == null)
{
System.Diagnostics.Debug.WriteLine("no ended handler");
}
if (this.Ended != null)
{
this.Ended(this, new AnimationEndedEventArgs(info));
}
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
if (this.itemsToAnimate != null)
{
for (int i = 0; i < this.itemsToAnimate.Count; i++)
{
FrameworkElement itemToAnimate = this.itemsToAnimate[i];
this.SetItemOriginalTransform(itemToAnimate);
}
}
base.ApplyAnimationValues(info);
}
private static Storyboard GetStoryboard(UIElement target, Func <PlayAnimationInfo, bool> predicate)
{
List <PlayAnimationInfo> infos = null;
if (!RunningAnimations.TryGetValue(target.GetHashCode(), out infos))
{
return(null);
}
PlayAnimationInfo result = infos.SingleOrDefault <PlayAnimationInfo>(arg => predicate(arg));
return(result == null ? null : result.Storyboard);
}
/// <inheritdoc/>
protected override void OnEnded(PlayAnimationInfo info)
{
this.itemsOriginalTransform.Clear();
this.containerToAnimate = null;
this.elementToDelay = null;
if (this.itemsToAnimate != null)
{
this.itemsToAnimate.Clear();
this.itemsToAnimate = null;
}
base.OnEnded(info);
}
private static void StopStoryboard(PlayAnimationInfo info)
{
// try to notify the associated animation for stopping the storyboard
// this is needed to record the final animation values as Local if needed
info.Animation.OnStopping(info);
info.Storyboard.Stop();
info.Animation.OnStopped(info);
info.Storyboard.Children.Clear();
info.Storyboard.Completed -= OnStoryboardCompleted;
RemoveAnimationInfo(info);
InvokeCallbacks(info.Storyboard);
}
private static void RemoveAnimationInfo(PlayAnimationInfo info)
{
int targetHash = info.TargetHashCode;
List <PlayAnimationInfo> playPasses = RunningAnimations[targetHash];
Debug.Assert(playPasses != null && playPasses.Count > 0, "PlayInfo must be registered.");
playPasses.Remove(info);
if (playPasses.Count == 0)
{
RunningAnimations.Remove(targetHash);
}
info.Storyboard.ClearValue(AnimationInfoProperty);
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
double?scaleX;
if (this.GetAutoReverse())
{
scaleX = this.StartScaleX;
}
else
{
scaleX = this.EndScaleX;
}
ScaleTransform transform = info.Target.GetScaleTransform();
transform.ScaleX = scaleX.HasValue ? scaleX.Value : transform.ScaleX;
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
double opacity = 0;
if (this.GetAutoReverse())
{
opacity = this.StartOpacity;
}
else
{
opacity = this.EndOpacity;
}
if (info.Target.Opacity != opacity)
{
info.Target.Opacity = opacity;
}
}
/// <summary>
/// Called by the animation manager when the storyboard has been started.
/// </summary>
/// <param name="info"></param>
protected internal override void OnStarted(PlayAnimationInfo info)
{
if (this.headerElementScreenShotInfo != null)
{
RadAnimationManager.Play(this.headerElementScreenShotInfo.ScreenShotContainer, this.headerElementAnimation);
}
if (this.applicationHeaderElementScreenShotInfo != null)
{
RadAnimationManager.Play(this.applicationHeaderElementScreenShotInfo.ScreenShotContainer, this.applicationHeaderElementAnimation);
}
if (this.pageAnimation != null)
{
RadAnimationManager.Play(info.Target, this.pageAnimation);
}
base.OnStarted(info);
}
private static PlayAnimationInfo CreatePlayAnimationInfo(UIElement target, RadAnimation animation, Storyboard storyboard)
{
int hash = target.GetHashCode();
List <PlayAnimationInfo> animations = null;
PlayAnimationInfo result = new PlayAnimationInfo(storyboard, animation, target);
if (!RunningAnimations.TryGetValue(hash, out animations))
{
animations = new List <PlayAnimationInfo>();
animations.Add(result);
RunningAnimations[hash] = animations;
}
else
{
animations.Add(result);
}
return(result);
}
/// <inheritdoc/>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
if (info == null)
{
return;
}
double?scaleY;
if (this.GetAutoReverse())
{
scaleY = this.StartScaleY;
}
else
{
scaleY = this.EndScaleY;
}
ScaleTransform transform = info.Target.GetScaleTransform();
transform.ScaleY = scaleY.HasValue ? scaleY.Value : transform.ScaleY;
}
/// <inheritdoc/>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
if (info == null)
{
return;
}
double endX = 0;
FrameworkElement target = info.Target as FrameworkElement;
if (this.GetAutoReverse())
{
if (this.PointMode == MoveAnimationPointMode.Absolute)
{
endX = GetX(target, this.StartX);
}
else
{
endX = GetRelativeX(target, this.StartX);
}
}
else
{
if (this.PointMode == MoveAnimationPointMode.Absolute)
{
endX = GetX(target, this.EndX);
}
else
{
endX = GetRelativeX(target, this.EndX);
}
}
target.GetTranslateTransform().X = endX;
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationEndedEventArgs" /> class.
/// </summary>
/// <param name="target">The target.</param>
internal AnimationEndedEventArgs(PlayAnimationInfo target)
{
this.AnimationInfo = target;
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info">The animation info.</param>
protected internal virtual void ApplyAnimationValues(PlayAnimationInfo info)
{
}
/// <summary>
/// Called by the animation manager when the storyboard has been started.
/// </summary>
/// <param name="info">The info.</param>
protected internal virtual void OnStarted(PlayAnimationInfo info)
{
}
/// <summary>
/// Allows inheritors to store the animated values.
/// This is useful if the animation wants to keep the final values upon storyboard stopping.
/// </summary>
/// <param name="info">The info.</param>
protected virtual void CopyAnimationValues(PlayAnimationInfo info)
{
}
/// <summary>
/// Applies already stored (if any) animated values.
/// </summary>
/// <param name="info"></param>
protected internal override void ApplyAnimationValues(PlayAnimationInfo info)
{
base.ApplyAnimationValues(info);
}
