// Manages the fade animation
private static Task ManageCompositionFadeSlidenimationAsync(this UIElement element,
float? startOp, float endOp,
int ms, int? msDelay, EasingFunctionNames easingFunction)
{
// Get the default values
Visual visual = element.GetVisual();
visual.StopAnimation("Opacity");
if (!startOp.HasValue) startOp = visual.Opacity;
// Get the easing function, the duration and delay
CompositionEasingFunction ease = visual.GetEasingFunction(easingFunction);
TimeSpan duration = TimeSpan.FromMilliseconds(ms);
TimeSpan? delay;
if (msDelay.HasValue) delay = TimeSpan.FromMilliseconds(msDelay.Value);
else delay = null;
// Get the opacity the animation
ScalarKeyFrameAnimation opacityAnimation = visual.Compositor.CreateScalarKeyFrameAnimation(endOp, startOp, duration, delay, ease);
// Close the batch and manage its event
CompositionScopedBatch batch = visual.Compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
batch.Completed += (s, e) => tcs.SetResult(null);
visual.StartAnimation("Opacity", opacityAnimation);
batch.End();
return tcs.Task;
}
public static CubicBezierEasingFunction GetEasingFunction(this CompositionObject compObject, EasingFunctionNames ease)
{
switch (ease)
{
case EasingFunctionNames.Linear: return GetCubicBeizerFunction(compObject, 0, 0, 1, 1);
case EasingFunctionNames.SineEaseIn: return GetCubicBeizerFunction(compObject, 0.4f, 0, 1, 1);
case EasingFunctionNames.SineEaseOut: return GetCubicBeizerFunction(compObject, 0, 0, 0.6f, 1);
case EasingFunctionNames.SineEaseInOut: return GetCubicBeizerFunction(compObject, 0, 0.4f, 0.6f, 1);
case EasingFunctionNames.QuadraticEaseIn: return GetCubicBeizerFunction(compObject, 0, 0.8f, 1, 1);
case EasingFunctionNames.QuadraticEaseOut: return GetCubicBeizerFunction(compObject, 0, 0.4f, 0.8f, 1);
case EasingFunctionNames.QuadraticEaseInOut: return GetCubicBeizerFunction(compObject, 0, 0.6f, 0.3f, 1);
default: throw new ArgumentOutOfRangeException(nameof(ease), ease, "This shouldn't happen");
}
}
/// <summary>
/// Converts an easing function name to the right easing function
/// </summary>
/// <param name="ease">The desired easing function</param>
public static EasingFunctionBase ToEasingFunction(this EasingFunctionNames ease)
{
switch (ease)
{
case EasingFunctionNames.Linear: return(null);
case EasingFunctionNames.SineEaseIn: return(new SineEase {
EasingMode = EasingMode.EaseIn
});
case EasingFunctionNames.SineEaseOut: return(new SineEase {
EasingMode = EasingMode.EaseOut
});
case EasingFunctionNames.SineEaseInOut: return(new SineEase {
EasingMode = EasingMode.EaseInOut
});
case EasingFunctionNames.QuadraticEaseIn: return(new QuadraticEase {
EasingMode = EasingMode.EaseIn
});
case EasingFunctionNames.QuadraticEaseOut: return(new QuadraticEase {
EasingMode = EasingMode.EaseOut
});
case EasingFunctionNames.QuadraticEaseInOut: return(new QuadraticEase {
EasingMode = EasingMode.EaseInOut
});
case EasingFunctionNames.CircleEaseIn: return(new CircleEase {
EasingMode = EasingMode.EaseIn
});
case EasingFunctionNames.CircleEaseOut: return(new CircleEase {
EasingMode = EasingMode.EaseOut
});
case EasingFunctionNames.CircleEaseInOut: return(new CircleEase {
EasingMode = EasingMode.EaseInOut
});
default: throw new ArgumentOutOfRangeException(nameof(ease), ease, "This shouldn't happen");
}
}
// Manages the fade and slide animation
private static Task ManageCompositionFadeSlideAnimationAsync(this UIElement element,
float? startOp, float endOp,
TranslationAxis axis, float? startXY, float endXY,
int msOp, int? msSlide, int? msDelay, EasingFunctionNames easingFunction)
{
// Get the default values
Visual visual = element.GetVisual();
visual.StopAnimation("Opacity");
visual.StopAnimation("Offset");
if (!startOp.HasValue) startOp = visual.Opacity;
// Get the easing function, the duration and delay
CompositionEasingFunction ease = visual.GetEasingFunction(easingFunction);
TimeSpan durationOp = TimeSpan.FromMilliseconds(msOp);
TimeSpan durationSlide = TimeSpan.FromMilliseconds(msSlide ?? msOp);
TimeSpan? delay;
if (msDelay.HasValue) delay = TimeSpan.FromMilliseconds(msDelay.Value);
else delay = null;
// Calculate the initial and final offset values
Vector3 initialOffset = visual.Offset;
Vector3 endOffset = visual.Offset;
if (axis == TranslationAxis.X)
{
if (startXY.HasValue) initialOffset.X = startXY.Value;
endOffset.X = endXY;
}
else
{
if (startXY.HasValue) initialOffset.Y = startXY.Value;
endOffset.Y = endXY;
}
// Get the batch
CompositionScopedBatch batch = visual.Compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
// Get the opacity the animation
ScalarKeyFrameAnimation opacityAnimation = visual.Compositor.CreateScalarKeyFrameAnimation(endOp, startOp, durationOp, delay, ease);
// Offset animation
Vector3KeyFrameAnimation offsetAnimation = visual.Compositor.CreateVector3KeyFrameAnimation(endOffset, initialOffset, durationSlide, delay, ease);
// Close the batch and manage its event
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
batch.Completed += (s, e) => tcs.SetResult(null);
visual.StartAnimation("Opacity", opacityAnimation);
visual.StartAnimation("Offset", offsetAnimation);
batch.End();
return tcs.Task;
}
/// <summary>
/// Starts a fade animation on the target UIElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
public static Task StartCompositionFadeAnimationAsync(this UIElement element,
float? startOp, float endOp,
int ms, int? msDelay, EasingFunctionNames easingFunction)
{
return ManageCompositionFadeSlidenimationAsync(element, startOp, endOp, ms, msDelay, easingFunction);
}
/// <summary>
/// Starts an offset animation on the target FrameworkElement and optionally runs a callback Action when the animations finish
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="axis">The offset axis</param>
/// <param name="startOffset">The initial offset X and Y value. If null, the current offset will be used</param>
/// <param name="endOffset">The final offset X and Y value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
/// <param name="callback">An Action to execute when the new animations end</param>
public static async void StartCompositionSlideAnimation(this FrameworkElement element,
TranslationAxis axis, float? startOffset, float endOffset,
int ms, int? msDelay, EasingFunctionNames easingFunction, bool reverse = false, Action callback = null)
{
await element.ManageCompositionSlideAnimationAsync(axis, startOffset, endOffset, ms, msDelay, easingFunction);
callback?.Invoke();
}
/// <summary>
/// Starts a scale animation on the target FrameworkElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startScale">The initial scale X and Y value. If null, the current scale will be used</param>
/// <param name="endScale">The final scale X and Y value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static async Task StartCompositionScaleAnimationAsync(this FrameworkElement element,
float? startScale, float endScale,
int ms, int? msDelay, EasingFunctionNames easingFunction, bool reverse = false)
{
startScale = await ManageCompositionScaleAnimationAsync(element, startScale, endScale, ms, msDelay, easingFunction);
if (reverse) await ManageCompositionScaleAnimationAsync(element, endScale, startScale.Value, ms, msDelay, easingFunction);
}
// Manages the scale animation
private static async Task<float> ManageCompositionScaleAnimationAsync(this FrameworkElement element,
float? startXY, float endXY,
int ms, int? msDelay, EasingFunctionNames easingFunction)
{
// Get the default values and set the CenterPoint
Visual visual = element.GetVisual();
visual.StopAnimation("Scale");
await element.SetCenterPoint(visual);
// Get the easing function, the duration and delay
CompositionEasingFunction ease = visual.GetEasingFunction(easingFunction);
TimeSpan duration = TimeSpan.FromMilliseconds(ms);
TimeSpan? delay;
if (msDelay.HasValue) delay = TimeSpan.FromMilliseconds(msDelay.Value);
else delay = null;
// Calculate the initial and final scale values
Vector3 initialScale = visual.Scale;
if (startXY.HasValue)
{
initialScale.X = startXY.Value;
initialScale.Y = startXY.Value;
}
Vector3 endScale = new Vector3
{
X = endXY,
Y = endXY,
Z = visual.Scale.Z
};
// Scale animation
Vector3KeyFrameAnimation offsetAnimation = visual.Compositor.CreateVector3KeyFrameAnimation(endScale, initialScale, duration, delay, ease);
// Get the batch and start the animations
CompositionScopedBatch batch = visual.Compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
batch.Completed += (s, e) => tcs.SetResult(null);
visual.StartAnimation("Scale", offsetAnimation);
batch.End();
await tcs.Task;
return initialScale.X;
}
/// <summary>
/// Animates the target color brush to a given color
/// </summary>
/// <param name="solidColorBrush">The brush to animate</param>
/// <param name="toColor">The target color to set</param>
/// <param name="ms">The duration of the animation</param>
/// <param name="easing">The easing function to use</param>
public static void AnimateColor(this SolidColorBrush solidColorBrush, String toColor, int ms, EasingFunctionNames easing)
{
// Get the target color
Color targetColor = ColorConverter.String2Color(toColor);
if (solidColorBrush.Color.Equals(targetColor))
{
return;
}
// Prepare the animation
ColorAnimation animation = new ColorAnimation
{
From = solidColorBrush.Color,
To = targetColor,
Duration = new Duration(TimeSpan.FromMilliseconds(ms)),
EasingFunction = easing.ToEasingFunction()
};
Storyboard.SetTarget(animation, solidColorBrush);
Storyboard.SetTargetProperty(animation, "Color");
Storyboard storyboard = new Storyboard();
storyboard.Children.Add(animation);
storyboard.Begin();
}
/// <summary>
/// Slides a target element over a given axis
/// </summary>
/// <param name="element">The element to animate</param>
/// <param name="axis">A String that indicates which axis to use with the TranslateTransform animation</param>
/// <param name="startXY">The initial axis value</param>
/// <param name="endXY">The final axis value</param>
/// <param name="ms">The duration of the animation in milliseconds</param>
/// <param name="easing">The easing function to use in the animation</param>
public static Storyboard GetXAMLTransformSlideStoryboard(this UIElement element,
TranslationAxis axis, double?startXY, double?endXY, int ms, EasingFunctionNames easing)
{
// Try to get the original starting value if necessary
TranslateTransform translate = element.RenderTransform as TranslateTransform;
bool cleanAnimation = startXY != null;
if (startXY == null && translate != null)
{
startXY = axis == TranslationAxis.X ? element.RenderTransform.To <TranslateTransform>().X : element.RenderTransform.To <TranslateTransform>().Y;
}
// Prepare and run the animation
if (translate == null || cleanAnimation)
{
translate = new TranslateTransform();
element.RenderTransform = translate;
}
return(XAMLTransformToolkit.PrepareStory(XAMLTransformToolkit.CreateDoubleAnimation(translate, axis.ToPropertyString(), startXY, endXY, ms, easing)));
}
/// <summary>
/// Starts and wait a fade and slide animation on the target UIElement
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="axis">The offset axis to use on the translation animation</param>
/// <param name="startXY">The initial offset value. If null, the current offset will be used</param>
/// <param name="endXY">The final offset value</param>
/// <param name="ms">The duration of the fade animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static Task StartXAMLTransformSlideAnimationAsync(this UIElement element,
TranslationAxis axis, double?startXY, double?endXY,
int ms, int?msDelay, EasingFunctionNames easingFunction, bool reverse = false)
{
return(element.ManageXAMLTransformSlideAnimationAsync(axis, startXY, endXY, ms, msDelay, easingFunction, reverse));
}
/// <summary>
/// Starts a fade and slide animation on the target UIElement and optionally runs a callback Action when the animations finish
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="axis">The offset axis to use on the translation animation</param>
/// <param name="startXY">The initial offset value. If null, the current offset will be used</param>
/// <param name="endXY">The final offset value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="callback">An Action to execute when the new animations end</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static async void StartXAMLTransformSlideAnimation(this UIElement element,
TranslationAxis axis, double?startXY, double?endXY,
int ms, int?msDelay, EasingFunctionNames easingFunction, Action callback = null, bool reverse = false)
{
await element.ManageXAMLTransformSlideAnimationAsync(axis, startXY, endXY, ms, msDelay, easingFunction, reverse);
callback?.Invoke();
}
// Manages the scale animation
private static async Task ManageXAMLTransformFadeScaleAnimationAsync(this UIElement element,
double?startScale, double?endScale,
int ms, int?msDelay, EasingFunctionNames easingFunction, bool reverse)
{
// Delay if necessary
if (msDelay.HasValue)
{
await Task.Delay(msDelay.Value);
}
// Try to get the original starting values if necessary
if (startScale == null && element.RenderTransform is ScaleTransform)
{
ScaleTransform scale = element.RenderTransform.To <ScaleTransform>();
startScale = (scale.ScaleX + scale.ScaleY) / 2;
}
// Start and wait the animation
DoubleAnimation scaleX = XAMLTransformToolkit.CreateDoubleAnimation(element.GetRenderTransform <ScaleTransform>(), "ScaleX",
startScale, endScale, ms, easingFunction);
DoubleAnimation scaleY = XAMLTransformToolkit.CreateDoubleAnimation(element.GetRenderTransform <ScaleTransform>(), "ScaleY",
startScale, endScale, ms, easingFunction);
Storyboard storyboard = XAMLTransformToolkit.PrepareStory(scaleX, scaleY);
storyboard.AutoReverse = reverse;
await storyboard.WaitAsync();
}
// Manages the fade animation
private static async Task ManageXAMLTransformFadeAnimationAsync(this UIElement element,
double?startOp, double?endOp,
int ms, int?msDelay, EasingFunctionNames easingFunction, bool reverse)
{
// Delay if necessary
if (msDelay.HasValue)
{
await Task.Delay(msDelay.Value);
}
// Start and wait the animation
DoubleAnimation animation = XAMLTransformToolkit.CreateDoubleAnimation(element, "Opacity", startOp ?? element.Opacity, endOp, ms, easingFunction);
Storyboard storyboard = XAMLTransformToolkit.PrepareStory(animation);
storyboard.AutoReverse = reverse;
await storyboard.WaitAsync();
}
/// <summary>
/// Starts a fade and slide animation on the target UIElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="axis">The offset axis to use on the translation animation</param>
/// <param name="startXY">The initial offset value. If null, the current offset will be used</param>
/// <param name="endXY">The final offset value</param>
/// <param name="msOp">The duration of the fade animation, in milliseconds</param>
/// <param name="msSlide">The duration of the slide animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
public static Task StartCompositionFadeSlideAnimationAsync(this UIElement element,
float? startOp, float endOp,
TranslationAxis axis, float? startXY, float endXY,
int msOp, int? msSlide, int? msDelay, EasingFunctionNames easingFunction)
{
return ManageCompositionFadeSlideAnimationAsync(element, startOp, endOp, axis, startXY, endXY, msOp, msSlide, msDelay, easingFunction);
}
/// <summary>
/// Starts a fade and scale animation on the target FrameworkElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="startScale">The initial scale X and Y value. If null, the current scale will be used</param>
/// <param name="endScale">The final scale X and Y value</param>
/// <param name="msOp">The duration of the fade animation, in milliseconds</param>
/// <param name="msScale">The duration of the scale animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
public static Task StartCompositionFadeScaleAnimationAsync(this FrameworkElement element,
float? startOp, float endOp,
float? startScale, float endScale,
int msOp, int? msScale, int? msDelay, EasingFunctionNames easingFunction)
{
return ManageCompositionFadeScaleAnimationAsync(element, startOp, endOp, startScale, endScale, msOp, msScale, msDelay, easingFunction);
}
/// <summary>
/// Starts a fade animation on the target UIElement and optionally runs a callback Action when the animations finish
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="callback">An Action to execute when the new animations end</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static async void StartXAMLTransformFadeAnimation(this UIElement element,
double?startOp, double?endOp,
int ms, int?msDelay, EasingFunctionNames easingFunction, Action callback = null, bool reverse = false)
{
await ManageXAMLTransformFadeAnimationAsync(element, startOp, endOp, ms, msDelay, easingFunction, reverse);
callback?.Invoke();
}
/// <summary>
/// Starts a scale animation on the target FrameworkElement and optionally runs a callback Action when the animations finish
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startScale">The initial scale X and Y value. If null, the current scale will be used</param>
/// <param name="endScale">The final scale X and Y value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
/// <param name="callback">An Action to execute when the new animations end</param>
public static async void StartCompositionScaleAnimation(this FrameworkElement element,
float? startScale, float endScale,
int ms, int? msDelay, EasingFunctionNames easingFunction, bool reverse = false, Action callback = null)
{
await element.StartCompositionScaleAnimationAsync(startScale, endScale, ms, msDelay, easingFunction, reverse);
callback?.Invoke();
}
/// <summary>
/// Starts a fade animation on the target UIElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static Task StartXAMLTransformFadeAnimationAsync(this UIElement element,
double?startOp, double?endOp,
int ms, int?msDelay, EasingFunctionNames easingFunction, bool reverse = false)
{
return(ManageXAMLTransformFadeAnimationAsync(element, startOp, endOp, ms, msDelay, easingFunction, reverse));
}
// Manages the scale animation
private static async Task<float> ManageCompositionSlideAnimationAsync(this FrameworkElement element,
TranslationAxis axis, float? startXY, float endXY,
int ms, int? msDelay, EasingFunctionNames easingFunction)
{
// Get the default values
Visual visual = element.GetVisual();
visual.StopAnimation("Offset");
// Get the easing function, the duration and delay
CompositionEasingFunction ease = visual.GetEasingFunction(easingFunction);
TimeSpan duration = TimeSpan.FromMilliseconds(ms);
TimeSpan? delay;
if (msDelay.HasValue) delay = TimeSpan.FromMilliseconds(msDelay.Value);
else delay = null;
// Calculate the initial and final offset values
Vector3 initialOffset = visual.Offset;
Vector3 endOffset = visual.Offset;
if (axis == TranslationAxis.X)
{
if (startXY.HasValue) initialOffset.X = startXY.Value;
endOffset.X = endXY;
}
else
{
if (startXY.HasValue) initialOffset.Y = startXY.Value;
endOffset.Y = endXY;
}
// Scale animation
Vector3KeyFrameAnimation offsetAnimation = visual.Compositor.CreateVector3KeyFrameAnimation(endOffset, initialOffset, duration, delay, ease);
// Get the batch and start the animations
CompositionScopedBatch batch = visual.Compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
batch.Completed += (s, e) => tcs.SetResult(null);
visual.StartAnimation("Offset", offsetAnimation);
batch.End();
await tcs.Task;
return initialOffset.X;
}
// Manages the fade and slide animation
private static async Task ManageXAMLTransformFadeSlideAnimationAsync(this UIElement element,
double?startOp, double?endOp,
TranslationAxis axis, double?startXY, double?endXY,
int msOp, int?msSlide, int?msDelay, EasingFunctionNames easingFunction, bool reverse)
{
// Delay if necessary
if (msDelay.HasValue)
{
await Task.Delay(msDelay.Value);
}
// Try to get the original starting value if necessary
if (startXY == null && element.RenderTransform is TranslateTransform)
{
startXY = axis == TranslationAxis.X ? element.RenderTransform.To <TranslateTransform>().X : element.RenderTransform.To <TranslateTransform>().Y;
}
// Start and wait the animation
DoubleAnimation opacity = XAMLTransformToolkit.CreateDoubleAnimation(element, "Opacity", startOp ?? element.Opacity, endOp, msOp, easingFunction);
DoubleAnimation slide = XAMLTransformToolkit.CreateDoubleAnimation(element.GetRenderTransform <TranslateTransform>(),
axis.ToPropertyString(), startXY, endXY,
msSlide ?? msOp, easingFunction);
Storyboard storyboard = XAMLTransformToolkit.PrepareStory(opacity, slide);
storyboard.AutoReverse = reverse;
await storyboard.WaitAsync();
}
/// <summary>
/// Starts an offset animation on the target FrameworkElement and returns a Task that completes when the animation ends
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="axis">The offset axis</param>
/// <param name="startOffset">The initial offset X and Y value. If null, the current offset will be used</param>
/// <param name="endOffset">The final offset X and Y value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="reverse">If true, the animation will be played in reverse mode when it finishes for the first time</param>
public static async Task StartCompositionSlideAnimationAsync(this FrameworkElement element,
TranslationAxis axis, float? startOffset, float endOffset,
int ms, int? msDelay, EasingFunctionNames easingFunction, bool reverse = false)
{
startOffset = await element.ManageCompositionSlideAnimationAsync(axis, startOffset, endOffset, ms, msDelay, easingFunction);
if (reverse) await element.ManageCompositionSlideAnimationAsync(axis, endOffset, startOffset.Value, ms, msDelay, easingFunction);
}
/// <summary>
/// Prepares a an animation with the given info
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The property to animate inside the target object</param>
/// <param name="from">The initial property value</param>
/// <param name="to">The final property value</param>
/// <param name="ms">The duration of the animation</param>
/// <param name="easing">The easing function to use inside the animation</param>
/// <param name="enableDependecyAnimations">Indicates whether or not to apply this animation to elements that need the visual tree to be rearranged</param>
public static DoubleAnimation CreateDoubleAnimation(DependencyObject target, String property,
double?from, double?to, int ms, EasingFunctionNames easing = EasingFunctionNames.Linear, bool enableDependecyAnimations = false)
{
DoubleAnimation animation = new DoubleAnimation
{
From = from,
To = to,
Duration = new Duration(TimeSpan.FromMilliseconds(ms)),
EnableDependentAnimation = enableDependecyAnimations
};
if (easing != EasingFunctionNames.Linear)
{
animation.EasingFunction = easing.ToEasingFunction();
}
Storyboard.SetTarget(animation, target);
Storyboard.SetTargetProperty(animation, property);
return(animation);
}
/// <summary>
/// Starts a fade animation on the target UIElement and optionally runs a callback Action when the animations finish
/// </summary>
/// <param name="element">The UIElement to animate</param>
/// <param name="startOp">The initial opacity value. If null, the current opacity will be used</param>
/// <param name="endOp">The final opacity value</param>
/// <param name="ms">The duration of the animation, in milliseconds</param>
/// <param name="msDelay">The delay before the animation starts, in milliseconds. If null, there will be no delay</param>
/// <param name="easingFunction">The easing function to use with the new animations</param>
/// <param name="callback">An Action to execute when the new animations end</param>
public static async void StartCompositionFadeAnimation(this UIElement element,
float? startOp, float endOp,
int ms, int? msDelay, EasingFunctionNames easingFunction, Action callback = null)
{
await ManageCompositionFadeSlidenimationAsync(element, startOp, endOp, ms, msDelay, easingFunction);
callback?.Invoke();
}
public static CubicBezierEasingFunction GetEasingFunction(this CompositionObject compObject, EasingFunctionNames ease)
{
switch (ease)
{
case EasingFunctionNames.Linear: return(GetCubicBeizerFunction(compObject, 0, 0, 1, 1));
case EasingFunctionNames.SineEaseIn: return(GetCubicBeizerFunction(compObject, 0.4f, 0, 1, 1));
case EasingFunctionNames.SineEaseOut: return(GetCubicBeizerFunction(compObject, 0, 0, 0.6f, 1));
case EasingFunctionNames.SineEaseInOut: return(GetCubicBeizerFunction(compObject, 0.4f, 0, 0.6f, 1));
case EasingFunctionNames.QuadraticEaseIn: return(GetCubicBeizerFunction(compObject, 0.8f, 0, 1, 1));
case EasingFunctionNames.QuadraticEaseOut: return(GetCubicBeizerFunction(compObject, 0, 0, 0.2f, 1));
case EasingFunctionNames.QuadraticEaseInOut: return(GetCubicBeizerFunction(compObject, 0.8f, 0, 0.2f, 1));
case EasingFunctionNames.CircleEaseIn: return(GetCubicBeizerFunction(compObject, 1, 0, 1, 0.8f));
case EasingFunctionNames.CircleEaseOut: return(GetCubicBeizerFunction(compObject, 0, 0.3f, 0, 1));
case EasingFunctionNames.CircleEaseInOut: return(GetCubicBeizerFunction(compObject, 0.9f, 0, 0.1f, 1));
default: throw new ArgumentOutOfRangeException(nameof(ease), ease, "This shouldn't happen");
}
}
