DotNet 4.8.1 build of DotNetBar

PROMS/DotNetBar Source Code/Animation/Animation.cs

@@ -0,0 +1,772 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.ComponentModel;
+using System.Windows.Forms;
+using DevComponents.DotNetBar;
+using System.Drawing;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal abstract class Animation : Component
+    {
+        #region Events
+        /// <summary>
+        /// Occurs after animation has completed.
+        /// </summary>
+        public event EventHandler AnimationCompleted;
+        /// <summary>
+        /// Raises AnimationCompleted event.
+        /// </summary>
+        /// <param name="e">Provides event arguments.</param>
+        protected virtual void OnAnimationCompleted(EventArgs e)
+        {
+            EventHandler handler = AnimationCompleted;
+            if (handler != null)
+                handler(this, e);
+        }
+        #endregion
+
+        #region Constructor
+        private BackgroundWorker _Worker = null;
+        private AnimationEasing _EasingFunction = AnimationEasing.EaseOutQuad;
+        private double _Duration = 300;
+        private EasingFunctionDelegate[] _AnimationFunctions;
+        private List<AnimationRequest> _AnimationList = new List<AnimationRequest>();
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public Animation(AnimationEasing animationEasing, int animationDuration)
+            :
+            this(new AnimationRequest[0], animationEasing, animationDuration)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public Animation(AnimationRequest animationRequest, AnimationEasing animationEasing, int animationDuration)
+            :
+            this(new AnimationRequest[] { animationRequest }, animationEasing, animationDuration)
+        {
+        }
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public Animation(AnimationRequest[] animationRequests, AnimationEasing animationEasing, int animationDuration)
+        {
+            if (animationRequests != null && animationRequests.Length > 0)
+                _AnimationList.AddRange(animationRequests);
+            _EasingFunction = animationEasing;
+            _Duration = (int)animationDuration;
+            InitializeAnimationFunctions();
+        }
+
+        private void InitializeAnimationFunctions()
+        {
+            _AnimationFunctions = new EasingFunctionDelegate[28];
+            _AnimationFunctions[(int)AnimationEasing.EaseInBounce] = new EasingFunctionDelegate(EaseInBounce);
+            _AnimationFunctions[(int)AnimationEasing.EaseInCirc] = new EasingFunctionDelegate(EaseInCirc);
+            _AnimationFunctions[(int)AnimationEasing.EaseInCubic] = new EasingFunctionDelegate(EaseInCubic);
+            _AnimationFunctions[(int)AnimationEasing.EaseInElastic] = new EasingFunctionDelegate(EaseInElastic);
+            _AnimationFunctions[(int)AnimationEasing.EaseInExpo] = new EasingFunctionDelegate(EaseInExpo);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutBounce] = new EasingFunctionDelegate(EaseInOutBounce);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutCirc] = new EasingFunctionDelegate(EaseInOutCirc);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutCubic] = new EasingFunctionDelegate(EaseInOutCubic);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutElastic] = new EasingFunctionDelegate(EaseInOutElastic);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutExpo] = new EasingFunctionDelegate(EaseInOutExpo);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutQuad] = new EasingFunctionDelegate(EaseInOutQuad);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutQuart] = new EasingFunctionDelegate(EaseInOutQuart);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutQuint] = new EasingFunctionDelegate(EaseInOutQuint);
+            _AnimationFunctions[(int)AnimationEasing.EaseInOutSine] = new EasingFunctionDelegate(EaseInOutSine);
+            _AnimationFunctions[(int)AnimationEasing.EaseInQuad] = new EasingFunctionDelegate(EaseInQuad);
+            _AnimationFunctions[(int)AnimationEasing.EaseInQuart] = new EasingFunctionDelegate(EaseInQuart);
+            _AnimationFunctions[(int)AnimationEasing.EaseInQuint] = new EasingFunctionDelegate(EaseInQuint);
+            _AnimationFunctions[(int)AnimationEasing.EaseInSine] = new EasingFunctionDelegate(EaseInSine);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutBounce] = new EasingFunctionDelegate(EaseOutBounce);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutCirc] = new EasingFunctionDelegate(EaseOutCirc);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutCubic] = new EasingFunctionDelegate(EaseOutCubic);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutElastic] = new EasingFunctionDelegate(EaseOutElastic);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutExpo] = new EasingFunctionDelegate(EaseOutExpo);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutQuad] = new EasingFunctionDelegate(EaseOutQuad);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutQuart] = new EasingFunctionDelegate(EaseOutQuart);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutQuint] = new EasingFunctionDelegate(EaseOutQuint);
+            _AnimationFunctions[(int)AnimationEasing.EaseOutSine] = new EasingFunctionDelegate(EaseOutSine);
+            _AnimationFunctions[(int)AnimationEasing.Linear] = new EasingFunctionDelegate(Linear);
+
+        }
+        #endregion
+
+        #region Implementation
+        private bool _AutoDispose = false;
+        /// <summary>
+        /// Gets or sets whether animation is auto-disposed once its completed. Default value is false.
+        /// </summary>
+        public bool AutoDispose
+        {
+            get { return _AutoDispose; }
+            set
+            {
+                _AutoDispose = value;
+            }
+        }
+
+        public List<AnimationRequest> Animations
+        {
+            get
+            {
+                return _AnimationList;
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            //Console.WriteLine("{0} Animation DISPOSED", DateTime.Now);
+            Stop();
+            _IsDisposed = true;
+            base.Dispose(disposing);
+        }
+
+        private bool _IsDisposed = false;
+        public bool IsDisposed
+        {
+            get { return _IsDisposed; }
+            internal set
+            {
+                _IsDisposed = value;
+            }
+        }
+
+        /// <summary>
+        /// Stops animation if one is currently running.
+        /// </summary>
+        public void Stop()
+        {
+            BackgroundWorker worker = _Worker;
+            if (worker != null)
+            {
+                worker.DoWork -= new DoWorkEventHandler(WorkerDoWork);
+                worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(RunWorkerCompleted);
+                worker.CancelAsync();
+                worker.Dispose();
+                _Worker = null;
+            }
+        }
+
+        public void Start()
+        {
+            Start(_AnimationList.ToArray());
+        }
+
+        protected void Start(AnimationRequest[] requests)
+        {
+            if (_Worker != null)
+                throw new InvalidOperationException("Animation is already running animations");
+            //Console.WriteLine("{0} Animation Started", DateTime.Now);
+            _IsCompleted = false;
+            _Worker = new BackgroundWorker();
+            _Worker.WorkerSupportsCancellation = true;
+            _Worker.DoWork += new DoWorkEventHandler(WorkerDoWork);
+            _Worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);
+            _Worker.RunWorkerAsync(requests);
+        }
+
+        private void RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+        {
+            //Console.WriteLine(string.Format("{0}  RunWorkerCompleted", DateTime.Now));
+            BackgroundWorker worker = _Worker;
+            _Worker = null;
+            if (worker != null)
+            {
+                worker.DoWork -= new DoWorkEventHandler(WorkerDoWork);
+                worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(RunWorkerCompleted);
+                worker.Dispose();
+            }
+
+            _IsCompleted = true;
+            OnAnimationCompleted(EventArgs.Empty);
+
+            if (_AutoDispose)
+                this.Dispose();
+        }
+
+        protected virtual void SetTargetPropertyValue(object target, PropertyInfo property, object value)
+        {
+            Control c = target as Control;
+            if (c != null)
+            {
+                c.Invoke(new MethodInvoker(delegate
+                {
+                    property.SetValue(target, value, null);
+                    if (c.Parent != null)
+                        c.Parent.Update();
+                    else
+                        c.Update();
+                }));
+            }
+            else if (target is BaseItem)
+            {
+                if (_AnimationUpdateControl != null)
+                    _AnimationUpdateControl.Invoke(new MethodInvoker(delegate { property.SetValue(target, value, null); if (value is Rectangle) _AnimationUpdateControl.Invalidate(); }));
+                else
+                {
+                    if (target is DevComponents.DotNetBar.Metro.MetroTileItem && property.Name == "CurrentFrameOffset")
+                        ((DevComponents.DotNetBar.Metro.MetroTileItem)target).CurrentFrameOffset = (int)value;
+                    else
+                        property.SetValue(target, value, null);
+                }
+            }
+            else
+            {
+                property.SetValue(target, value, null);
+            }
+        }
+        protected abstract object GetPropertyValueCorrectType(double value);
+
+        protected virtual void WorkerDoWork(object sender, DoWorkEventArgs e)
+        {
+            AnimationRequest[] requests = (AnimationRequest[])e.Argument;
+            double elapsedTime = 0;
+            DateTime startTime = DateTime.UtcNow;
+            double duration = _Duration;
+
+            bool firstPass = true;
+
+            if (_FixedStepCount <= 0)
+            {
+                while (elapsedTime <= duration)
+                {
+                    try
+                    {
+                        foreach (AnimationRequest request in requests)
+                        {
+                            double toValue = request.GetToValue();
+                            double fromValue = request.GetFromValue();
+                            double change = toValue - fromValue;
+
+                            if (firstPass)
+                                SetTargetPropertyValue(request.Target, request.Property, request.From);
+
+                            double r = _AnimationFunctions[(int)_EasingFunction](elapsedTime, fromValue, change, duration);
+                            if (change < 0 && r < toValue || change > 0 && r > toValue) { r = toValue; e.Cancel = true; break; }
+                            if (change < 0 && r > fromValue || change > 0 && r < fromValue) r = fromValue;
+
+                            SetTargetPropertyValue(request.Target, request.Property, GetPropertyValueCorrectType(r));
+                            elapsedTime = DateTime.UtcNow.Subtract(startTime).TotalMilliseconds;
+                            if (e.Cancel) break;
+                        }
+
+                        if (e.Cancel) break;
+
+                        ExecuteStepUpdateMethod();
+
+                        if (_AnimationUpdateControl != null)
+                        {
+                            if (_AnimationUpdateControl.InvokeRequired)
+                                _AnimationUpdateControl.BeginInvoke(new MethodInvoker(delegate { _AnimationUpdateControl.Update(); }));
+                            else
+                                _AnimationUpdateControl.Update();
+                        }
+                        if (e.Cancel) break;
+                        firstPass = false;
+                    }
+                    catch (TargetInvocationException exc)
+                    {
+                        if (exc.InnerException is ObjectDisposedException) // Stop work if target has been disposed
+                            return;
+                        throw;
+                    }
+                }
+            }
+            else
+            {
+                try
+                {
+                    for (int i = 0; i < _FixedStepCount; i++)
+                    {
+                        foreach (AnimationRequest request in requests)
+                        {
+                            double toValue = request.GetToValue();
+                            double fromValue = request.GetFromValue();
+                            double change = toValue - fromValue;
+                            double step = change / _FixedStepCount;
+
+                            if (firstPass)
+                                SetTargetPropertyValue(request.Target, request.Property, request.From);
+
+                            double r = fromValue + step * (i + 1);
+                            if (change < 0 && r < toValue || change > 0 && r > toValue) { r = toValue; e.Cancel = true; break; }
+                            if (change < 0 && r > fromValue || change > 0 && r < fromValue) r = fromValue;
+
+                            SetTargetPropertyValue(request.Target, request.Property, GetPropertyValueCorrectType(r));
+                            if (e.Cancel) break;
+                            if (_Duration > 0)
+                            {
+                                try
+                                {
+                                    using (
+                                        System.Threading.ManualResetEvent wait =
+                                            new System.Threading.ManualResetEvent(false))
+                                        wait.WaitOne((int) _Duration);
+
+                                    //System.Threading.Thread.Sleep((int)_Duration);
+                                }
+                                catch
+                                {
+                                    break;
+                                }
+
+                            }
+                        }
+
+                        if (e.Cancel) break;
+
+                        ExecuteStepUpdateMethod();
+
+                        if (_AnimationUpdateControl != null)
+                            _AnimationUpdateControl.Update();
+                        if (e.Cancel) break;
+                        firstPass = false;
+                    }
+                }
+                catch (TargetInvocationException exc)
+                {
+                    if (exc.InnerException is ObjectDisposedException) // Stop work if target has been disposed
+                        return;
+                    throw;
+                }
+            }
+            // Make sure final to value is assigned
+            foreach (AnimationRequest request in requests)
+            {
+                try
+                {
+                    SetTargetPropertyValue(request.Target, request.Property, request.To);
+                }
+                catch (TargetInvocationException exc)
+                {
+                    if (exc.InnerException is ObjectDisposedException) // Stop work if target has been disposed
+                        continue;
+                    throw;
+                }
+            }
+            //System.Diagnostics.Debug.WriteLine(string.Format("{0}  WorkerDoWork DONE", DateTime.Now));
+        }
+        private bool _IsCompleted;
+        /// <summary>
+        /// Gets whether animation run is complete.
+        /// </summary>
+        public bool IsCompleted
+        {
+            get { return _IsCompleted; }
+        }
+        /// <summary>
+        /// Gets the animation duration in milliseconds.
+        /// </summary>
+        public double Duration
+        {
+            get { return _Duration; }
+            internal set
+            {
+                _Duration = value;
+            }
+        }
+        /// <summary>
+        /// Gets the animation easing function.
+        /// </summary>
+        public AnimationEasing EasingFunction
+        {
+            get
+            {
+                return _EasingFunction;
+            }
+        }
+
+        protected EasingFunctionDelegate[] AnimationFunctions
+        {
+            get
+            {
+                return _AnimationFunctions;
+            }
+        }
+
+        protected virtual void ExecuteStepUpdateMethod()
+        {
+            if (_StepUpdateMethod != null)
+                _StepUpdateMethod.DynamicInvoke(null);
+        }
+
+        private Delegate _StepUpdateMethod = null;
+        /// <summary>
+        /// Sets the method which is called each time value on target object property is set. This method may execute the visual updates on animation client.
+        /// </summary>
+        /// <param name="method">Method to call</param>
+        public void SetStepUpdateMethod(Delegate method)
+        {
+            _StepUpdateMethod = method;
+        }
+
+        protected delegate double EasingFunctionDelegate(double t, double b, double c, double d);
+
+        private Control _AnimationUpdateControl;
+        public Control AnimationUpdateControl
+        {
+            get { return _AnimationUpdateControl; }
+            set { _AnimationUpdateControl = value; }
+        }
+
+        private int _FixedStepCount = 0;
+        /// <summary>
+        /// Gets or sets the number of fixed steps animation will perform from star to finish instead of using the easing function in time.
+        /// Stepped animation executes specified number of steps always with Duration specifying delays between each step.
+        /// </summary>
+        public int FixedStepCount
+        {
+            get { return _FixedStepCount; }
+            set
+            {
+                _FixedStepCount = value;
+            }
+        }
+        #endregion
+
+        #region Easing Functions
+        private double EaseInOutQuad(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;
+        }
+        private double EaseInQuad(double t, double b, double c, double d)
+        {
+            return c * (t /= d) * t + b;
+        }
+        private double EaseOutQuad(double t, double b, double c, double d)
+        {
+            return -c * (t /= d) * (t - 2) + b;
+        }
+        private double EaseInCubic(double t, double b, double c, double d)
+        {
+            return c * (t /= d) * t * t + b;
+        }
+        private double EaseOutCubic(double t, double b, double c, double d)
+        {
+            return c * ((t = t / d - 1) * t * t + 1) + b;
+        }
+        private double EaseInOutCubic(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;
+        }
+        private double EaseInQuart(double t, double b, double c, double d)
+        {
+            return c * (t /= d) * t * t * t + b;
+        }
+        private double EaseOutQuart(double t, double b, double c, double d)
+        {
+            return -c * ((t = t / d - 1) * t * t * t - 1) + b;
+        }
+        private double EaseInOutQuart(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;
+        }
+        private double EaseInQuint(double t, double b, double c, double d)
+        {
+            return c * (t /= d) * t * t * t * t + b;
+        }
+        private double EaseOutQuint(double t, double b, double c, double d)
+        {
+            return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+        }
+        private double EaseInOutQuint(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;
+        }
+        private double EaseInSine(double t, double b, double c, double d)
+        {
+            return -c * Math.Cos(t / d * (Math.PI / 2)) + c + b;
+        }
+        private double EaseOutSine(double t, double b, double c, double d)
+        {
+            return c * Math.Sin(t / d * (Math.PI / 2)) + b;
+        }
+        private double EaseInOutSine(double t, double b, double c, double d)
+        {
+            return -c / 2 * (Math.Cos(Math.PI * t / d) - 1) + b;
+        }
+        private double EaseInExpo(double t, double b, double c, double d)
+        {
+            return (t == 0) ? b : c * Math.Pow(2, 10 * (t / d - 1)) + b;
+        }
+        private double EaseOutExpo(double t, double b, double c, double d)
+        {
+            return (t == d) ? b + c : c * (-Math.Pow(2, -10 * t / d) + 1) + b;
+        }
+        private double EaseInOutExpo(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;
+        }
+        private double EaseInCirc(double t, double b, double c, double d)
+        {
+            return -c * (Math.Sqrt(1 - (t /= d) * t) - 1) + b;
+        }
+        private double EaseOutCirc(double t, double b, double c, double d)
+        {
+            return c * Math.Sqrt(1 - (t = t / d - 1) * t) + b;
+        }
+        private double EaseInOutCirc(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;
+        }
+        private double EaseInElastic(double t, double b, double c, double d)
+        {
+            double s = 1.70158;
+            double p = 0;
+            double a = c;
+            if (t == 0)
+                return b;
+            if ((t /= d) == 1)
+                return b + c;
+            if (p == 0)
+                p = d * .3;
+            if (a < Math.Abs(c))
+            {
+                a = c;
+                s = p / 4;
+            }
+            else
+                s = p / (2 * Math.PI) * Math.Asin(c / a);
+            return -(a * Math.Pow(2, 10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p)) + b;
+        }
+        private double EaseOutElastic(double t, double b, double c, double d)
+        {
+            double s = 1.70158;
+            double p = 0;
+            double a = c;
+            if (t == 0)
+                return b;
+            if ((t /= d) == 1)
+                return b + c;
+            if (p == 0) p = d * .3;
+            if (a < Math.Abs(c))
+            {
+                a = c;
+                s = p / 4;
+            }
+            else
+                s = p / (2 * Math.PI) * Math.Asin(c / a);
+            return a * Math.Pow(2, -10 * t) * Math.Sin((t * d - s) * (2 * Math.PI) / p) + c + b;
+        }
+        private double EaseInOutElastic(double t, double b, double c, double d)
+        {
+            double s = 1.70158;
+            double p = 0;
+            double a = c;
+            if (t == 0)
+                return b;
+            if ((t /= d / 2) == 2)
+                return b + c;
+            if (p == 0)
+                p = d * (.3 * 1.5);
+            if (a < Math.Abs(c))
+            {
+                a = c;
+                s = p / 4;
+            }
+            else
+                s = p / (2 * Math.PI) * Math.Asin(c / a);
+            if (t < 1)
+                return -.5 * (a * Math.Pow(2, 10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p)) + b;
+            return a * Math.Pow(2, -10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
+        }
+
+        private double EaseInBounce(double t, double b, double c, double d)
+        {
+            return c - EaseOutBounce(d - t, 0, c, d) + b;
+        }
+        private double EaseOutBounce(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;
+            }
+        }
+        private double EaseInOutBounce(double t, double b, double c, double d)
+        {
+            if (t < d / 2) return EaseInBounce(t * 2, 0, c, d) * .5 + b;
+            return EaseOutBounce(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
+        }
+
+        private double Linear(double t, double b, double c, double d)
+        {
+            return (t / d) * c + b;
+        }
+        #endregion
+    }
+
+    internal class AnimationRequest
+    {
+        private PropertyInfo _TargetProperty = null;
+
+        /// <summary>
+        /// Initializes a new instance of the AnimationRequest class.
+        /// </summary>
+        /// <param name="target">Target object for animation.</param>
+        /// <param name="targetPropertyName">Target property name for animation.</param>
+        /// <param name="from">From value.</param>
+        /// <param name="to">To value.</param>
+        public AnimationRequest(object target, string targetPropertyName, object to)
+        {
+            _TargetProperty = target.GetType().GetProperty(targetPropertyName);
+            _Target = target;
+            From = _TargetProperty.GetValue(target, null);
+            To = to;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the AnimationRequest class.
+        /// </summary>
+        /// <param name="target">Target object for animation.</param>
+        /// <param name="targetPropertyName">Target property name for animation.</param>
+        /// <param name="from">From value.</param>
+        /// <param name="to">To value.</param>
+        public AnimationRequest(object target, string targetPropertyName, object from, object to)
+        {
+            _TargetProperty = target.GetType().GetProperty(targetPropertyName);
+            _Target = target;
+            From = from;
+            To = to;
+        }
+
+        private object _Target;
+        /// <summary>
+        /// Target object for animation.
+        /// </summary>
+        public object Target
+        {
+            get { return _Target; }
+            set { _Target = value; }
+        }
+
+        private object _From;
+        /// <summary>
+        /// Animation from value.
+        /// </summary>
+        public object From
+        {
+            get { return _From; }
+            set
+            {
+                _From = value;
+                _FromValue = GetDoubleValue(value);
+            }
+        }
+
+        private object _To;
+        /// <summary>
+        /// Animation to value.
+        /// </summary>
+        public object To
+        {
+            get { return _To; }
+            set
+            {
+                _To = value;
+                _ToValue = GetDoubleValue(value);
+            }
+        }
+
+        private static double GetDoubleValue(object value)
+        {
+            if (value is int)
+                return (double)(int)value;
+            else if (value is double)
+                return (double)value;
+            else if (value is long)
+                return (double)(long)value;
+            else if (value is float)
+                return (double)(float)value;
+
+            return double.NaN;
+        }
+
+        internal PropertyInfo Property
+        {
+            get
+            {
+                return _TargetProperty;
+            }
+        }
+
+        private double _ToValue = double.NaN;
+        internal double GetToValue()
+        {
+            return _ToValue;
+        }
+        private double _FromValue = double.NaN;
+        internal double GetFromValue()
+        {
+            return _FromValue;
+        }
+
+    }
+    /// <summary>
+    /// Specifies the animation easing function
+    /// </summary>
+    public enum AnimationEasing : int
+    {
+        EaseInOutQuad = 0,
+        EaseInQuad = 1,
+        EaseOutQuad = 2,
+        EaseInCubic = 3,
+        EaseOutCubic = 4,
+        EaseInOutCubic = 5,
+        EaseInQuart = 6,
+        EaseOutQuart = 7,
+        EaseInOutQuart = 8,
+        EaseInQuint = 9,
+        EaseOutQuint = 10,
+        EaseInOutQuint = 11,
+        EaseInSine = 12,
+        EaseOutSine = 13,
+        EaseInOutSine = 14,
+        EaseInExpo = 15,
+        EaseOutExpo = 16,
+        EaseInOutExpo = 17,
+        EaseInCirc = 18,
+        EaseOutCirc = 19,
+        EaseInOutCirc = 20,
+        EaseInElastic = 21,
+        EaseOutElastic = 22,
+        EaseInOutElastic = 23,
+        EaseInBounce = 24,
+        EaseOutBounce = 25,
+        EaseInOutBounce = 26,
+        Linear = 27
+    }
+}

PROMS/DotNetBar Source Code/Animation/AnimationDouble.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal class AnimationDouble : Animation
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationDouble(AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[0], animationEasing, animationDuration)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationDouble(AnimationRequest animationRequest, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[] { animationRequest }, animationEasing, animationDuration)
+        {
+        }
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationDouble(AnimationRequest[] animationRequests, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(animationRequests, animationEasing, animationDuration) { }
+        #endregion
+
+        protected override object GetPropertyValueCorrectType(double value)
+        {
+            return value;
+        }
+    }
+}

PROMS/DotNetBar Source Code/Animation/AnimationInt.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal class AnimationInt : Animation
+    {
+        
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationInt(AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[0], animationEasing, animationDuration)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationInt(AnimationRequest animationRequest, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[] { animationRequest }, animationEasing, animationDuration)
+        {
+        }
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationInt(AnimationRequest[] animationRequests, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(animationRequests, animationEasing, animationDuration) { }
+        #endregion
+
+        protected override object GetPropertyValueCorrectType(double value)
+        {
+            return (int)value;
+        }
+
+
+    }
+}

PROMS/DotNetBar Source Code/Animation/AnimationPoint.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using System.ComponentModel;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal class AnimationPoint : Animation
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationPoint(AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[0], animationEasing, animationDuration)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationPoint(AnimationRequest animationRequest, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[] { animationRequest }, animationEasing, animationDuration)
+        {
+        }
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationPoint(AnimationRequest[] animationRequests, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(animationRequests, animationEasing, animationDuration) { }
+        #endregion
+
+        #region Implementation
+        protected override void WorkerDoWork(object sender, DoWorkEventArgs e)
+        {
+            AnimationRequest[] requests = (AnimationRequest[])e.Argument;
+            double elapsedTime = 0;
+            DateTime startTime = DateTime.Now;
+            double duration = Duration;
+
+            bool firstPass = true;
+            while (elapsedTime <= duration)
+            {
+                foreach (AnimationRequest request in requests)
+                {
+                    Point toValue = (Point)request.To;
+                    Point fromValue = (Point)request.From;
+                    Point change = new Point(toValue.X - fromValue.X, toValue.Y - fromValue.Y);
+                    Point newValue = toValue;
+
+                    if (firstPass)
+                        SetTargetPropertyValue(request.Target, request.Property, request.From);
+
+                    if (change.X != 0)
+                        newValue.X = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.X, change.X, duration);
+                    if (change.Y != 0)
+                        newValue.Y = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.Y, change.Y, duration);
+
+                    SetTargetPropertyValue(request.Target, request.Property, newValue);
+
+                    elapsedTime = DateTime.Now.Subtract(startTime).TotalMilliseconds;
+
+                    if (e.Cancel) return;
+                }
+
+                ExecuteStepUpdateMethod();
+
+                if (AnimationUpdateControl != null)
+                    AnimationUpdateControl.Update();
+
+                firstPass = false;
+            }
+
+            // Make sure final to value is assigned
+            foreach (AnimationRequest request in requests)
+            {
+                SetTargetPropertyValue(request.Target, request.Property, request.To);
+            }
+        }
+
+        protected override object GetPropertyValueCorrectType(double value)
+        {
+            return (int)value;
+        }
+        #endregion
+
+    }
+}

PROMS/DotNetBar Source Code/Animation/AnimationRectangle.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal class AnimationRectangle : Animation
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationRectangle(AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[0], animationEasing, animationDuration)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationRectangle(AnimationRequest animationRequest, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(new AnimationRequest[] { animationRequest }, animationEasing, animationDuration)
+        {
+        }
+        /// <summary>
+        /// Initializes a new instance of the Animation class.
+        /// </summary>
+        /// <param name="target">Target object for animation</param>
+        /// <param name="targetPropertyName">Target property name for animation</param>
+        public AnimationRectangle(AnimationRequest[] animationRequests, AnimationEasing animationEasing, int animationDuration)
+            :
+            base(animationRequests, animationEasing, animationDuration) { }
+        #endregion
+
+        #region Implementation
+        protected override void WorkerDoWork(object sender, DoWorkEventArgs e)
+        {
+            AnimationRequest[] requests = (AnimationRequest[])e.Argument;
+            double elapsedTime = 0;
+            DateTime startTime = DateTime.Now;
+            double duration = Duration;
+
+            bool firstPass = true;
+            while (elapsedTime <= duration)
+            {
+                foreach (AnimationRequest request in requests)
+                {
+                    Rectangle toValue = (Rectangle)request.To;
+                    Rectangle fromValue = (Rectangle)request.From;
+                    Rectangle change = new Rectangle(toValue.X - fromValue.X, toValue.Y - fromValue.Y, 
+                        toValue.Width - fromValue.Width, toValue.Height - fromValue.Height);
+                    Rectangle newValue = toValue;
+                    if (IsDisposed(request.Target)) return;
+                    if (firstPass)
+                        SetTargetPropertyValue(request.Target, request.Property, request.From);
+                    
+                    if (change.X != 0)
+                        newValue.X = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.X, change.X, duration);
+                    if (change.Y != 0)
+                        newValue.Y = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.Y, change.Y, duration);
+                    if (change.Width != 0)
+                        newValue.Width = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.Width, change.Width, duration);
+                    if (change.Height != 0)
+                        newValue.Height = (int)AnimationFunctions[(int)EasingFunction](elapsedTime, fromValue.Height, change.Height, duration);
+
+                    SetTargetPropertyValue(request.Target, request.Property, newValue);
+
+                    elapsedTime = DateTime.Now.Subtract(startTime).TotalMilliseconds;
+
+                    if (e.Cancel) return;
+                }
+                
+                ExecuteStepUpdateMethod();
+
+                //if (AnimationUpdateControl != null)
+                //    AnimationUpdateControl.Invoke(new MethodInvoker(delegate { AnimationUpdateControl.Update(); }));
+
+                firstPass = false;
+            }
+
+            // Make sure final to value is assigned
+            foreach (AnimationRequest request in requests)
+            {
+                SetTargetPropertyValue(request.Target, request.Property, request.To);
+            }
+
+            //Console.WriteLine("{0}  WorkerDoWork Complete", DateTime.Now);
+        }
+
+        private bool IsDisposed(object p)
+        {
+            if (p == null) return true;
+            if (p is Control && ((Control)p).IsDisposed) return true;
+            if (p is BaseItem && ((BaseItem)p).IsDisposed) return true;
+            return false;
+        }
+
+        protected override object GetPropertyValueCorrectType(double value)
+        {
+            return (int)value;
+        }
+        #endregion
+
+    }
+}

PROMS/DotNetBar Source Code/Animation/Storyline.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.ComponentModel;
+using System.Threading;
+
+namespace DevComponents.DotNetBar.Animation
+{
+    internal class Storyline : Component
+    {
+        #region Events
+
+        #endregion
+
+        #region Constructor
+
+        #endregion
+
+        #region Implementation
+        private bool _IsDisposed = false;
+        /// <summary>
+        /// Returns whether Storyline is disposed.
+        /// </summary>
+        public bool IsDisposed
+        {
+            get
+            {
+                return _IsDisposed;
+            }
+        }
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                BackgroundWorker worker = _Worker;
+                if (worker != null)
+                {
+                    worker.CancelAsync();
+                    worker.Dispose();
+                    _Worker = null;
+                }
+            }
+            _IsDisposed = true;
+            base.Dispose(disposing);
+        }
+
+        private List<Animation> _Animations = new List<Animation>();
+        /// <summary>
+        /// Gets the list of animations to run using this storyline.
+        /// </summary>
+        public List<Animation> Animations
+        {
+            get
+            {
+                return _Animations;
+            }
+        }
+
+        private BackgroundWorker _Worker = null;
+        /// <summary>
+        /// Runs all animations from Animations list.
+        /// </summary>
+        public void Run()
+        {
+            if (_Worker != null)
+                throw new InvalidOperationException("Storyline is already running animations");
+
+            _Worker = new BackgroundWorker();
+            _Worker.WorkerReportsProgress = true;
+            _Worker.WorkerSupportsCancellation = true;
+            _Worker.DoWork += new DoWorkEventHandler(WorkerDoWork);
+            _Worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);
+            _Worker.RunWorkerAsync();
+        }
+
+        void RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+        {
+            if (_RepeatStoryTimes > 0)
+            {
+                if (_Worker == null)
+                {
+                    _RepeatStoryTimes = 0;
+                    return;
+                }
+
+                _RepeatStoryTimes--;
+                _Worker.RunWorkerAsync();
+            }
+            else
+            {
+                if (_Worker != null)
+                    _Worker.Dispose();
+                _Worker = null;
+                if (_AutoDispose && !_IsDisposed)
+                    this.Dispose();
+            }
+        }
+
+        void WorkerDoWork(object sender, DoWorkEventArgs e)
+        {
+            int count = _Animations.Count;
+            for (int i = 0; i < count; i++)
+            {
+                if (e.Cancel) return;
+                _Animations[i].Start();
+                while (!_Animations[i].IsCompleted)
+                {
+                    try
+                    {
+                        using (
+                                        System.Threading.ManualResetEvent wait =
+                                            new System.Threading.ManualResetEvent(false))
+                            wait.WaitOne(50);
+                        //Thread.Sleep(50);
+                    }
+                    catch 
+                    {
+                        _Animations[i].Stop();
+                        return;
+                    }
+                    if (e.Cancel)
+                    {
+                        _Animations[i].Stop();
+                        return;
+                    }
+                }
+            }
+        }
+
+        private int _RepeatStoryTimes = 0;
+        /// <summary>
+        /// Gets or sets number of times storyline is repeated. Default value is 0 which indicates that storyline is run only once meaning not repeated.
+        /// </summary>
+        public int RepeatStoryTimes
+        {
+            get { return _RepeatStoryTimes; }
+            set { _RepeatStoryTimes = value; }
+        }
+
+        private bool _AutoDispose = false;
+        /// <summary>
+        /// Gets or sets whether storyline is auto-disposed when finished.
+        /// </summary>
+        public bool AutoDispose
+        {
+            get { return _AutoDispose; }
+            set
+            {
+                _AutoDispose = value;
+            }
+        }
+        #endregion
+
+    }
+}