private void OnAnimationAdded(RadAnimation radAnimation)
{
if (radAnimation.AnimationName != null)
{
this.availableAnimations.Add(radAnimation.AnimationName, radAnimation);
}
}
private void OnAnimationRemoved(RadAnimation radAnimation)
{
if (this.availableAnimations.ContainsKey(radAnimation.AnimationName))
{
this.availableAnimations.Remove(radAnimation.AnimationName);
}
}
/// <summary>
/// Updates the slide animation.
/// </summary>
/// <param name="control">The control for which the animation needs to be updated.</param>
/// <param name="storyboard">Storyvoard that needs to be updated.</param>
/// <param name="target">The targeted element of the animation.</param>
/// <param name="args"></param>
/// <remarks>
/// Currently the method sets the SpeedRatio of the storyboard to
/// the global <strong>AnimationSpeedRatio</strong> if the local SpeedRatio is null.
/// If the local SpeedRatio value is set, it will be used.
/// </remarks>
protected override void UpdateAnimationOverride(FrameworkElement control, Storyboard storyboard, FrameworkElement target, params object[] args)
{
this.UpdateSlideMode(target, args);
if (target.ActualHeight == 0)
{
// TODO: Discuss LayoutUpdate here.
target.UpdateLayout();
}
var value = target.ActualHeight;
var nonZeroValue = this.SlideMode == SlideMode.Top ? 1.0 : -1.0;
var relativeFrom = this.GetValueDependingOnDirection(nonZeroValue, 0.0);
var relatoveTo = this.GetValueDependingOnDirection(0.0, nonZeroValue);
value *= -1 * nonZeroValue;
var fromValue = this.GetValueDependingOnDirection(value, 0.0);
var endValue = this.GetValueDependingOnDirection(0.0, value);
var duration = RadAnimation.GetDurationSecondsForLength(Math.Abs(value));
var splineToUse = this.GetValueDependingOnDirection(Easings.SlideDown1, Easings.SlideUp1);
storyboard.Update()
.Animate(target)
.OpacityMaskRelativeMoveY(0, relativeFrom, duration, relatoveTo)
.Easings(splineToUse)
.MoveY(0, fromValue, duration, endValue)
.Easings(splineToUse);
DisableControlWhileAnimationIsRunning(target, storyboard);
}
internal static void SetAnimation(DependencyObject obj, RadAnimation value)
{
if (value == null)
{
obj.SetValue(AnimationProperty, null);
}
else
{
obj.SetValue(AnimationProperty, new WeakReference(value));
}
}
/// <summary>
/// Updates the slide animation.
/// </summary>
/// <param name="control">The control for which the animation needs to be updated.</param>
/// <param name="storyboard">Storyvoard that needs to be updated.</param>
/// <param name="target">The targeted element of the animation.</param>
/// <param name="args"></param>
/// <remarks>
/// Currently the method sets the SpeedRatio of the storyboard to
/// the global <strong>AnimationSpeedRatio</strong> if the local SpeedRatio is null.
/// If the local SpeedRatio value is set, it will be used.
/// </remarks>
protected override void UpdateAnimationOverride(FrameworkElement control, Storyboard storyboard, FrameworkElement target, params object[] args)
{
var relativeFrom =
this.GetValueDependingOnDirection(this.MinOpacity, this.MaxOpacity);
var relativeTo =
this.GetValueDependingOnDirection(this.MaxOpacity, this.MinOpacity);
var duration = RadAnimation.GetDurationSecondsForLength(200.0);
storyboard.Update()
.Animate(target)
.Opacity(0, relativeFrom, duration, relativeTo)
.Easings(this.Easing)
.AdjustSpeed();
}
/// <summary>
/// Updates the slide animation.
/// </summary>
/// <param name="control">The control for which the animation needs to be updated.</param>
/// <param name="storyboard">Storyvoard that needs to be updated.</param>
/// <param name="target">The targeted element of the animation.</param>
/// <param name="args"></param>
/// <remarks>
/// Currently the method sets the SpeedRatio of the storyboard to
/// the global <strong>AnimationSpeedRatio</strong> if the local SpeedRatio is null.
/// If the local SpeedRatio value is set, it will be used.
/// </remarks>
protected override void UpdateAnimationOverride(FrameworkElement control, Storyboard storyboard, FrameworkElement target, params object[] args)
{
var relativeFrom =
this.GetValueDependingOnDirection(this.MinScale, this.MaxScale);
var relativeTo =
this.GetValueDependingOnDirection(this.MaxScale, this.MinScale);
var duration = RadAnimation.GetDurationSecondsForLength(100.0);
storyboard.Update()
.Animate(target)
.EnsureDefaultTransforms()
.ScaleX(0, relativeFrom, duration, relativeTo)
.Easings(this.Easing)
.ScaleY(0, relativeFrom, duration, relativeTo)
.Easings(this.Easing)
.AdjustSpeed();
}
/// <summary>
/// Plays an animation for the given control and invokes the callback on completion.
/// </summary>
/// <param name="target">The control for which to play the animation.</param>
/// <param name="animationName">The name of the animation.</param>
/// <param name="completeCallback">The callback to be called. The callback is always called.</param>
/// <param name="args">Optional oarameters for the animation, can be provided by the control.</param>
/// <returns>True if an aimation actually played, false otherwise.</returns>
public static bool Play(FrameworkElement target, string animationName, Action completeCallback, params object[] args)
{
bool animationsEnabled = AnimationManager.GetIsAnimationEnabled(target) && AnimationManager.IsGlobalAnimationEnabled;
if (!animationsEnabled || VisualTreeHelper.GetChildrenCount(target) <= 0)
{
BeginInvokeCallback(completeCallback, target);
return(false);
}
AnimationSelectorBase selector = null;
RadAnimation animation = null;
////FrameworkElement firstChild = VisualTreeHelper.GetChild(target, 0) as FrameworkElement;
////Storyboard storyboard = firstChild.Resources[animationName] as Storyboard;
Storyboard storyboard = target.Resources[animationName] as Storyboard;
if (storyboard == null)
{
selector = AnimationManager.GetAnimationSelector(target);
if (selector == null)
{
BeginInvokeCallback(completeCallback, target);
return(false);
}
animation = selector.SelectAnimation(target, animationName);
if (animation == null)
{
BeginInvokeCallback(completeCallback, target);
return(false);
}
storyboard = animation.CreateAnimation(target);
if (storyboard == null)
{
BeginInvokeCallback(completeCallback, target);
return(false);
}
else
{
storyboard.Completed += new EventHandler(OnStoryboardCompleted);
AnimationManager.SetAnimation(storyboard, animation);
target.Resources.Add(animationName, storyboard);
////firstChild.Resources.Add(animationName, storyboard);
}
}
RadAnimation sourceAnimation = AnimationManager.GetAnimation(storyboard);
AddCallback(storyboard, new Action(() => storyboard.Stop()));
if (completeCallback != null)
{
AddCallback(storyboard, completeCallback);
}
if (storyboard.Children.Count > 0)
{
sourceAnimation.UpdateAnimation(target, storyboard, args);
}
storyboard.Begin();
return(true);
}