PennerDoubleAnimation.cs - wpf-animation

‹r8

r13

Source path: svn/ trunk/ src/ WPF/ Animation/ PennerDoubleAnimation.cs

/**
 * PennerDoubleAnimation
 * Animates the value of a double property between two target values using 
 * Robert Penner's easing equations for interpolation over a specified Duration.
 *
 * @author		Darren David darren-code@lookorfeel.com
 * @version		1.0
 *
 * Credit/Thanks:
 * Robert Penner - The easing equations we all know and love 
 *   (http://robertpenner.com/easing/) [See License.txt for license info]
 * 
 * Lee Brimelow - initial port of Penner's equations to WPF 
 *   (http://thewpfblog.com/?p=12)
 * 
 * Zeh Fernando - additional equations (out/in) from 
 *   caurina.transitions.Tweener (http://code.google.com/p/tweener/)
 *   [See License.txt for license info]
 */


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using System.Windows;
using System.Windows.Media.Animation;
using System.ComponentModel;
using System.Globalization;

namespace LookOrFeel.Animation
{
    /// <summary>
    /// Animates the value of a double property between two target values using 
    /// Robert Penner's easing equations for interpolation over a specified Duration.
    /// </summary>
    /// <example>
    /// <code>
    /// // C#
    /// PennerDoubleAnimation anim = new PennerDoubleAnimation();
    /// anim.Type = PennerDoubleAnimation.Equations.Linear;
    /// anim.From = 1;
    /// anim.To = 0;
    /// myControl.BeginAnimation( OpacityProperty, anim );
    /// 
    /// // XAML
    /// <Storyboard x:Key="AnimateXamlRect">
    ///  <animation:PennerDoubleAnimation 
    ///    Storyboard.TargetName="myControl" 
    ///    Storyboard.TargetProperty="(Canvas.Left)"
    ///    From="0" 
    ///    To="600" 
    ///    Equation="BackEaseOut" 
    ///    Duration="00:00:05" />
    /// </Storyboard>
    /// 
    /// <Control.Triggers>
    ///   <EventTrigger RoutedEvent="FrameworkElement.Loaded">
    ///     <BeginStoryboard Storyboard="{StaticResource AnimateXamlRect}"/>
    ///   </EventTrigger>
    /// </Control.Triggers>
    /// </code>
    /// </example>
    public class PennerDoubleAnimation : DoubleAnimationBase
    {
        /// <summary>
        /// Enumeration of all easing equations.
        /// </summary>
        public enum Equations
        {
            Linear,
            QuadEaseOut, QuadEaseIn, QuadEaseInOut, QuadEaseOutIn,
            ExpoEaseOut, ExpoEaseIn, ExpoEaseInOut, ExpoEaseOutIn,
            CubicEaseOut, CubicEaseIn, CubicEaseInOut, CubicEaseOutIn,
            QuartEaseOut, QuartEaseIn, QuartEaseInOut, QuartEaseOutIn,
            QuintEaseOut, QuintEaseIn, QuintEaseInOut, QuintEaseOutIn,
            CircEaseOut, CircEaseIn, CircEaseInOut, CircEaseOutIn,
            SineEaseOut, SineEaseIn, SineEaseInOut, SineEaseOutIn,
            ElasticEaseOut, ElasticEaseIn, ElasticEaseInOut, ElasticEaseOutIn,
            BounceEaseOut, BounceEaseIn, BounceEaseInOut, BounceEaseOutIn,
            BackEaseOut, BackEaseIn, BackEaseInOut, BackEaseOutIn
        }

        #region Fields

        private MethodInfo _EasingMethod;

        #endregion

        #region Dependency Properties

        public static readonly DependencyProperty EquationProperty =
            DependencyProperty.Register(
                "Equation", typeof( Equations ), typeof( PennerDoubleAnimation ), 
                new PropertyMetadata( Equations.Linear, new PropertyChangedCallback( HandleEquationChanged ) ) );

        public static readonly DependencyProperty FromProperty =
            DependencyProperty.Register(
                "From", typeof( double ), typeof( PennerDoubleAnimation ), new PropertyMetadata( 0.0 ) );

        public static readonly DependencyProperty ToProperty =
            DependencyProperty.Register(
                "To", typeof( double ), typeof( PennerDoubleAnimation ), new PropertyMetadata( 0.0 ) );

        #endregion

        #region Constructors

        public PennerDoubleAnimation()
        {
        }

        public PennerDoubleAnimation( Equations type, double from, double to )
        {
            Equation = type;
            From = from;
            To = to;
        }

        public PennerDoubleAnimation( Equations type, double from, double to, Duration duration )
        {
            Equation = type;
            From = from;
            To = to;
            Duration = duration;
        }

        #endregion

        #region Abstract Member Implementations

        protected override double GetCurrentValueCore( double startValue, double targetValue, AnimationClock clock )
        {
            try
            {
                // might be able to speed this up by caching it, but who knows
                object[] methodParams = new object[4] { clock.CurrentTime.Value.TotalSeconds, From, To - From, Duration.TimeSpan.TotalSeconds };

                return ( double ) _EasingMethod.Invoke( this, methodParams );
            }
            catch
            {
                return From;
            }
        }

        protected override Freezable CreateInstanceCore()
        {
            return new PennerDoubleAnimation();
        }

        #endregion

        #region Equations

        // These methods are all public to enable reflection in GetCurrentValueCore.

        #region Linear

        /// <summary>
        /// Easing equation function for a simple linear tweening, with no easing.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double Linear( double t, double b, double c, double d )
        {
            return c * t / d + b;
        }

        #endregion

        #region Expo

        /// <summary>
        /// Easing equation function for an exponential (2^t) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ExpoEaseOut( double t, double b, double c, double d )
        {
            return ( t == d ) ? b + c : c * ( -Math.Pow( 2, -10 * t / d ) + 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for an exponential (2^t) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ExpoEaseIn( double t, double b, double c, double d )
        {
            return ( t == 0 ) ? b : c * Math.Pow( 2, 10 * ( t / d - 1 ) ) + b;
        }


        /// <summary>
        /// Easing equation function for an exponential (2^t) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ExpoEaseInOut( double t, double b, double c, double d )
        {
            if ( t == 0 )
                return b;

            if ( t == d )
                return b + c;

            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * Math.Pow( 2, 10 * ( t - 1 ) ) + b;

            return c / 2 * ( -Math.Pow( 2, -10 * --t ) + 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for an exponential (2^t) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ExpoEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return ExpoEaseOut( t * 2, b, c / 2, d );

            return ExpoEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Circular

        /// <summary>
        /// Easing equation function for a circular (sqrt(1-t^2)) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CircEaseOut( double t, double b, double c, double d )
        {
            return c * Math.Sqrt( 1 - ( t = t / d - 1 ) * t ) + b;
        }

        /// <summary>
        /// Easing equation function for a circular (sqrt(1-t^2)) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CircEaseIn( double t, double b, double c, double d )
        {
            return -c * ( Math.Sqrt( 1 - ( t /= d ) * t ) - 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a circular (sqrt(1-t^2)) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CircEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return -c / 2 * ( Math.Sqrt( 1 - t * t ) - 1 ) + b;

            return c / 2 * ( Math.Sqrt( 1 - ( t -= 2 ) * t ) + 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a circular (sqrt(1-t^2)) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CircEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return CircEaseOut( t * 2, b, c / 2, d );

            return CircEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Quad

        /// <summary>
        /// Easing equation function for a quadratic (t^2) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuadEaseOut( double t, double b, double c, double d )
        {
            return -c * ( t /= d ) * ( t - 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for a quadratic (t^2) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuadEaseIn( double t, double b, double c, double d )
        {
            return c * ( t /= d ) * t + b;
        }

        /// <summary>
        /// Easing equation function for a quadratic (t^2) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuadEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * t * t + b;

            return -c / 2 * ( ( --t ) * ( t - 2 ) - 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a quadratic (t^2) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuadEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return QuadEaseOut( t * 2, b, c / 2, d );

            return QuadEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Sine

        /// <summary>
        /// Easing equation function for a sinusoidal (sin(t)) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double SineEaseOut( double t, double b, double c, double d )
        {
            return c * Math.Sin( t / d * ( Math.PI / 2 ) ) + b;
        }

        /// <summary>
        /// Easing equation function for a sinusoidal (sin(t)) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double SineEaseIn( double t, double b, double c, double d )
        {
            return -c * Math.Cos( t / d * ( Math.PI / 2 ) ) + c + b;
        }


        /// <summary>
        /// Easing equation function for a sinusoidal (sin(t)) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double SineEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * ( Math.Sin( Math.PI * t / 2 ) ) + b;

            return -c / 2 * ( Math.Cos( Math.PI * --t / 2 ) - 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for a sinusoidal (sin(t)) easing in/out: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double SineEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return SineEaseOut( t * 2, b, c / 2, d );

            return SineEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Cubic

        /// <summary>
        /// Easing equation function for a cubic (t^3) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CubicEaseOut( double t, double b, double c, double d )
        {
            return c * ( ( t = t / d - 1 ) * t * t + 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a cubic (t^3) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CubicEaseIn( double t, double b, double c, double d )
        {
            return c * ( t /= d ) * t * t + b;
        }

        /// <summary>
        /// Easing equation function for a cubic (t^3) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CubicEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * t * t * t + b;

            return c / 2 * ( ( t -= 2 ) * t * t + 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for a cubic (t^3) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double CubicEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return CubicEaseOut( t * 2, b, c / 2, d );

            return CubicEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Quartic

        /// <summary>
        /// Easing equation function for a quartic (t^4) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuartEaseOut( double t, double b, double c, double d )
        {
            return -c * ( ( t = t / d - 1 ) * t * t * t - 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a quartic (t^4) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuartEaseIn( double t, double b, double c, double d )
        {
            return c * ( t /= d ) * t * t * t + b;
        }

        /// <summary>
        /// Easing equation function for a quartic (t^4) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuartEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * t * t * t * t + b;

            return -c / 2 * ( ( t -= 2 ) * t * t * t - 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for a quartic (t^4) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuartEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return QuartEaseOut( t * 2, b, c / 2, d );

            return QuartEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Quintic

        /// <summary>
        /// Easing equation function for a quintic (t^5) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuintEaseOut( double t, double b, double c, double d )
        {
            return c * ( ( t = t / d - 1 ) * t * t * t * t + 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a quintic (t^5) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuintEaseIn( double t, double b, double c, double d )
        {
            return c * ( t /= d ) * t * t * t * t + b;
        }

        /// <summary>
        /// Easing equation function for a quintic (t^5) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuintEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * t * t * t * t * t + b;
            return c / 2 * ( ( t -= 2 ) * t * t * t * t + 2 ) + b;
        }


        /// <summary>
        /// Easing equation function for a quintic (t^5) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double QuintEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return QuintEaseOut( t * 2, b, c / 2, d );
            return QuintEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Elastic

        /// <summary>
        /// Easing equation function for an elastic (exponentially decaying sine wave) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ElasticEaseOut( double t, double b, double c, double d )
        {
            if ( ( t /= d ) == 1 )
                return b + c;

            double p = d * .3;
            double s = p / 4;

            return ( c * Math.Pow( 2, -10 * t ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) + c + b );
        }

        /// <summary>
        /// Easing equation function for an elastic (exponentially decaying sine wave) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ElasticEaseIn( double t, double b, double c, double d )
        {
            if ( ( t /= d ) == 1 )
                return b + c;

            double p = d * .3;
            double s = p / 4;

            return -( c * Math.Pow( 2, 10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) ) + b;
        }

        /// <summary>
        /// Easing equation function for an elastic (exponentially decaying sine wave) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ElasticEaseInOut( double t, double b, double c, double d )
        {
            if ( ( t /= d / 2 ) == 2 )
                return b + c;

            double p = d * ( .3 * 1.5 );
            double s = p / 4;

            if ( t < 1 )
                return -.5 * ( c * Math.Pow( 2, 10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) ) + b;
            return c * Math.Pow( 2, -10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) * .5 + c + b;
        }

        /// <summary>
        /// Easing equation function for an elastic (exponentially decaying sine wave) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double ElasticEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return ElasticEaseOut( t * 2, b, c / 2, d );
            return ElasticEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Bounce

        /// <summary>
        /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BounceEaseOut( double t, double b, double c, double d )
        {
            if ( ( t /= d ) < ( 1 / 2.75 ) )
                return c * ( 7.5625 * t * t ) + b;
            else if ( t < ( 2 / 2.75 ) )
                return c * ( 7.5625 * ( t -= ( 1.5 / 2.75 ) ) * t + .75 ) + b;
            else if ( t < ( 2.5 / 2.75 ) )
                return c * ( 7.5625 * ( t -= ( 2.25 / 2.75 ) ) * t + .9375 ) + b;
            else
                return c * ( 7.5625 * ( t -= ( 2.625 / 2.75 ) ) * t + .984375 ) + b;
        }

        /// <summary>
        /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BounceEaseIn( double t, double b, double c, double d )
        {
            return c - BounceEaseOut( d - t, 0, c, d ) + b;
        }

        /// <summary>
        /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BounceEaseInOut( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return BounceEaseIn( t * 2, 0, c, d ) * .5 + b;
            else
                return BounceEaseOut( t * 2 - d, 0, c, d ) * .5 + c * .5 + b;
        }

        /// <summary>
        /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BounceEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return BounceEaseOut( t * 2, b, c / 2, d );
            return BounceEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #region Back

        /// <summary>
        /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out: 
        /// decelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BackEaseOut( double t, double b, double c, double d )
        {
            return c * ( ( t = t / d - 1 ) * t * ( ( 1.70158 + 1 ) * t + 1.70158 ) + 1 ) + b;
        }

        /// <summary>
        /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in: 
        /// accelerating from zero velocity.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BackEaseIn( double t, double b, double c, double d )
        {
            return c * ( t /= d ) * t * ( ( 1.70158 + 1 ) * t - 1.70158 ) + b;
        }


        /// <summary>
        /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out: 
        /// acceleration until halfway, then deceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BackEaseInOut( double t, double b, double c, double d )
        {
            double s = 1.70158;
            if ( ( t /= d / 2 ) < 1 )
                return c / 2 * ( t * t * ( ( ( s *= ( 1.525 ) ) + 1 ) * t - s ) ) + b;
            return c / 2 * ( ( t -= 2 ) * t * ( ( ( s *= ( 1.525 ) ) + 1 ) * t + s ) + 2 ) + b;
        }

        /// <summary>
        /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in: 
        /// deceleration until halfway, then acceleration.
        /// </summary>
        /// <param name="t">Current time in seconds.</param>
        /// <param name="b">Starting value.</param>
        /// <param name="c">Final value.</param>
        /// <param name="d">Duration of animation.</param>
        /// <returns>The correct value.</returns>
        public static double BackEaseOutIn( double t, double b, double c, double d )
        {
            if ( t < d / 2 )
                return BackEaseOut( t * 2, b, c / 2, d );
            return BackEaseIn( ( t * 2 ) - d, b + c / 2, c / 2, d );
        }

        #endregion

        #endregion

        #region Event Handlers

        private static void HandleEquationChanged( object sender, DependencyPropertyChangedEventArgs e )
        {
            PennerDoubleAnimation pda = sender as PennerDoubleAnimation;

            // cache method so we avoid lookup while animating
            pda._EasingMethod = typeof( PennerDoubleAnimation ).GetMethod( e.NewValue.ToString() );
        }

        #endregion

        #region Properties

        /// <summary>
        /// The easing equation to use.
        /// </summary>
        [TypeConverter( typeof( PennerDoubleAnimationTypeConverter ) )]
        public Equations Equation
        {
            get { return ( Equations ) GetValue( EquationProperty ); }
            set
            {
                SetValue( EquationProperty, value );

                // cache method so we avoid lookup while animating
                _EasingMethod = this.GetType().GetMethod( value.ToString() );
            }
        }

        /// <summary>
        /// Starting value for the animation.
        /// </summary>
        public double From
        {
            get { return ( double ) GetValue( FromProperty ); }
            set { SetValue( FromProperty, value ); }
        }

        /// <summary>
        /// Ending value for the animation.
        /// </summary>
        public double To
        {
            get { return ( double ) GetValue( ToProperty ); }
            set { SetValue( ToProperty, value ); }
        }

        #endregion
    }

    public class PennerDoubleAnimationTypeConverter : TypeConverter
    {
        public override bool CanConvertFrom( ITypeDescriptorContext context, Type sourceType )
        {
            return sourceType == typeof( string );
        }

        public override bool CanConvertTo( ITypeDescriptorContext context, Type destinationType )
        {
            return destinationType == typeof( Enum );
        }

        public override object ConvertFrom( ITypeDescriptorContext context, CultureInfo culture, object value )
        {
            foreach ( int i in Enum.GetValues( typeof( PennerDoubleAnimation.Equations ) ) )
            {
                if ( Enum.GetName( typeof( PennerDoubleAnimation.Equations ), i ) == value.ToString() )
                    return ( PennerDoubleAnimation.Equations ) i;
            }
            return null;
        }

        public override object ConvertTo( ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType )
        {
            if ( value != null )
            {
                return ( ( PennerDoubleAnimation.Equations ) value ).ToString();
            }
            return null;
        }
    }
}

Show details Hide details

Change log

r10 by darrendavid on Aug 15, 2007 Diff

migrating files into WPF dir

Go to:

Project members, sign in to write a code review

Older revisions

r6 by darrendavid on May 15, 2007 Diff

cleaning up source tree

r4 by darrendavid on May 15, 2007 Diff

changed HandleEquationChanged to cache
easing method directly rather than
call the CLR setter.

r2 by darrendavid on May 14, 2007 Diff

Initial commit.

All revisions of this file

File info

Size: 37890 bytes, 945 lines

View raw file

File properties

svn:executable: *