diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -7,3 +7,4 @@ Implab/bin/
 Implab/obj/
 TestResults/
 Implab.Fx/obj/
+Implab.Fx/bin/
diff --git a/Implab.Fx/Animation.cs b/Implab.Fx/Animation.cs
--- a/Implab.Fx/Animation.cs
+++ b/Implab.Fx/Animation.cs
@@ -2,14 +2,96 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Timers;
+using System.ComponentModel;
+using System.Diagnostics;
 
 namespace Implab.Fx
 {
-    public class Animation
+    public delegate void AnimationStep<T>(T target, int elapsed, int duration);
+
+    public class Animation<TArg> where TArg: class
     {
         int m_duration;
-        int m_fps;
+        int m_delay;
+        int m_elapsed;
+        int m_prevTicks;
+        TArg m_arg;
+        ISynchronizeInvoke m_syncronizationObject;
+
+        public event AnimationStep<TArg> Step;
+
+        Promise<TArg> m_promise;
+
+        public Animation(TArg target, int duration, int delay)
+        {
+            if (duration <= 0)
+                throw new ArgumentOutOfRangeException("duration");
+            if (delay <= 0)
+                throw new ArgumentOutOfRangeException("delay");
+
+            m_arg = target;
+            m_syncronizationObject = target as ISynchronizeInvoke;
+            m_duration = duration;
+            m_delay = delay;
+            m_promise = new Promise<TArg>();
+        }
+
+        public Animation(TArg target)
+            : this(target, 500, 30)
+        {
+        }
+
+        public TArg Traget
+        {
+            get { return m_arg; }
+        }
 
+        public Promise<TArg> Play()
+        {
+            var timer = new Timer(m_delay);
+            
+            timer.AutoReset = true;
+            timer.SynchronizingObject = m_syncronizationObject;
+            timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
 
+            m_prevTicks = Environment.TickCount;
+
+            timer.Start();
+
+            return m_promise;
+        }
+
+        void timer_Elapsed(object sender, ElapsedEventArgs args)
+        {
+            var timer = sender as Timer;
+
+            var dt = Environment.TickCount - m_prevTicks;
+            m_prevTicks = Environment.TickCount;
+
+            m_elapsed += dt;
+
+            if (m_elapsed > m_duration)
+                m_elapsed = m_duration;
+
+            try
+            {
+                var handler = Step;
+                if (handler != null)
+                    handler(m_arg, m_elapsed, m_duration);
+            }
+            catch (Exception e)
+            {
+                Trace.TraceError(e.ToString());
+            }
+
+            if (m_elapsed < m_duration)
+                timer.Start();
+            else
+            {
+                timer.Dispose();
+                m_promise.Resolve(m_arg);
+            }
+        }
     }
 }
diff --git a/Implab.Fx/AnimationHelpers.cs b/Implab.Fx/AnimationHelpers.cs
new file mode 100644
--- /dev/null
+++ b/Implab.Fx/AnimationHelpers.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+using System.Diagnostics;
+
+namespace Implab.Fx
+{
+    public static class AnimationHelpers
+    {
+        public static Animation<TTarget> AnimateProperty<TTarget,TVal>(this Animation<TTarget> animation, Action<TTarget,TVal> setter, Func<TTarget,TVal> getter, TVal newValue, Func<TVal,TVal,int,int,TVal> fx) where TTarget: class
+        {
+            if (animation == null)
+                throw new ArgumentNullException("animation");
+
+            TVal oldValue = getter(animation.Traget);
+
+            animation.Step += (target, elaped, duration) =>
+            {
+                var value = fx(oldValue, newValue, elaped, duration);
+                setter(target, value);
+            };
+
+            return animation;
+        }
+
+        public static Animation<Form> AnimateTransparency(this Form ctl, float newValue)
+        {
+            var anim = new Animation<Form>(ctl);
+
+            anim.AnimateProperty(
+                (target, value) => target.Opacity = value,
+                target => target.Opacity,
+                newValue,
+                (ov, nv, el, du) => ov + ((float)el / du) * (nv - ov)
+            );
+            return anim;
+        }
+    }
+}
diff --git a/Implab.Fx/ControlHelpers.cs b/Implab.Fx/ControlHelpers.cs
deleted file mode 100644
--- a/Implab.Fx/ControlHelpers.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows.Forms;
-
-namespace Implab.Fx
-{
-    public static class ControlHelpers
-    {
-        /// <summary>
-        /// Переключает обработку обещания в поток указанного элемента управления.
-        /// </summary>
-        /// <typeparam name="T">Тип результата обещания</typeparam>
-        /// <param name="that">Исходное обещание</param>
-        /// <param name="ctl">Элемент управления</param>
-        /// <returns>Новое обещание, обработчики которого будут выполнены в потоке элемента управления.</returns>
-        /// <exception cref="ArgumentNullException">Параметр не может быть <c>null</c>.</exception>
-        /// <example>
-        /// client
-        ///     .Get("description.txt") // returns a promise
-        ///     .DirectToControl(m_ctl) // handle the promise in the thread of the control
-        ///     .Then(
-        ///         description => m_ctl.Text = description // now it's safe
-        ///     )
-        /// </example>
-        public static Promise<T> DirectToControl<T>(this Promise<T> that, Control ctl)
-        {
-            if (that == null)
-                throw new ArgumentNullException("that");
-            if (ctl == null)
-                throw new ArgumentNullException("ctl");
-
-            var directed = new Promise<T>();
-
-            that.Then(
-                res =>
-                {
-                    if (ctl.InvokeRequired)
-                        ctl.Invoke(new Action<T>(directed.Resolve),res);
-                    else
-                        directed.Resolve(res);
-                },
-                err =>
-                {
-                    if (ctl.InvokeRequired)
-                        ctl.Invoke(new Action<Exception>(directed.Reject), err);
-                    else
-                        directed.Reject(err);
-                }
-            );
-
-            return directed;
-        }
-    }
-}
diff --git a/Implab.Fx/Implab.Fx.csproj b/Implab.Fx/Implab.Fx.csproj
--- a/Implab.Fx/Implab.Fx.csproj
+++ b/Implab.Fx/Implab.Fx.csproj
@@ -41,7 +41,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ControlHelpers.cs" />
+    <Compile Include="Animation.cs" />
+    <Compile Include="AnimationHelpers.cs" />
+    <Compile Include="PromiseHelpers.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Implab.Fx/PromiseHelpers.cs b/Implab.Fx/PromiseHelpers.cs
new file mode 100644
--- /dev/null
+++ b/Implab.Fx/PromiseHelpers.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+using System.Threading;
+
+namespace Implab.Fx
+{
+    public static class PromiseHelpers
+    {
+        /// <summary>
+        /// Перенаправляет обработку обещания в поток указанного элемента управления.
+        /// </summary>
+        /// <typeparam name="T">Тип результата обещания</typeparam>
+        /// <param name="that">Исходное обещание</param>
+        /// <param name="ctl">Элемент управления</param>
+        /// <returns>Новое обещание, обработчики которого будут выполнены в потоке элемента управления.</returns>
+        /// <exception cref="ArgumentNullException">Параметр не может быть <c>null</c>.</exception>
+        /// <example>
+        /// client
+        ///     .Get("description.txt") // returns a promise
+        ///     .DirectToControl(m_ctl) // handle the promise in the thread of the control
+        ///     .Then(
+        ///         description => m_ctl.Text = description // now it's safe
+        ///     )
+        /// </example>
+        public static Promise<T> DispatchToControl<T>(this Promise<T> that, Control ctl)
+        {
+            if (that == null)
+                throw new ArgumentNullException("that");
+            if (ctl == null)
+                throw new ArgumentNullException("ctl");
+
+            var directed = new Promise<T>();
+
+            that.Then(
+                res =>
+                {
+                    if (ctl.InvokeRequired)
+                        ctl.Invoke(new Action<T>(directed.Resolve), res);
+                    else
+                        directed.Resolve(res);
+                },
+                err =>
+                {
+                    if (ctl.InvokeRequired)
+                        ctl.Invoke(new Action<Exception>(directed.Reject), err);
+                    else
+                        directed.Reject(err);
+                }
+            );
+
+            return directed;
+        }
+
+        /// <summary>
+        /// Направляет обработку обещания в текущий поток, если у него существует контекст синхронизации.
+        /// </summary>
+        /// <typeparam name="T">Тип результата обещания.</typeparam>
+        /// <param name="that">Обещание которое нужно обработать в текущем потоке.</param>
+        /// <returns>Перенаправленное обещание.</returns>
+        public static Promise<T> DispatchToCurrentThread<T>(this Promise<T> that)
+        {
+            var sync = SynchronizationContext.Current;
+            if (sync == null)
+                throw new InvalidOperationException("The current thread doesn't have a syncronization context");
+            return DispatchToSyncContext(that, sync);
+        }
+
+        /// <summary>
+        /// Направляет обработку обещания в указанный контекст синхронизации.
+        /// </summary>
+        /// <typeparam name="T">Тип результата обещания.</typeparam>
+        /// <param name="that">Обещание, которое требуется обработать в указанном контексте синхронизации.</param>
+        /// <param name="sync">Контекст синхронизации в который будет направлено обещание.</param>
+        /// <returns>Новое обещание, которое будет обрабатываться в указанном контексте.</returns>
+        public static Promise<T> DispatchToSyncContext<T>(this Promise<T> that, SynchronizationContext sync)
+        {
+            if (that == null)
+                throw new ArgumentNullException("that");
+            if (sync == null)
+                throw new ArgumentNullException("sync");
+
+            var d = new Promise<T>();
+
+            that.Then(
+                res => sync.Post(state => d.Resolve(res), null),
+                err => sync.Post(state => d.Reject(err), null)
+            );
+
+            return d;
+        }
+    }
+}
diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs
--- a/Implab.Test/AsyncTests.cs
+++ b/Implab.Test/AsyncTests.cs
@@ -1,101 +1,101 @@
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Implab;
-using System.Reflection;
-using System.Threading;
-
-namespace Implab.Tests
-{
-	[TestClass]
-	public class AsyncTests
-	{
-		[TestMethod]
-		public void ResolveTest ()
-		{
-			int res = -1;
-			var p = new Promise<int> ();
-			p.Then (x => res = x);
-			p.Resolve (100);
-
-			Assert.AreEqual (res, 100);
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Implab;
+using System.Reflection;
+using System.Threading;
+
+namespace Implab.Tests
+{
+	[TestClass]
+	public class AsyncTests
+	{
+		[TestMethod]
+		public void ResolveTest ()
+		{
+			int res = -1;
+			var p = new Promise<int> ();
+			p.Then (x => res = x);
+			p.Resolve (100);
+
+			Assert.AreEqual (res, 100);
 		}
 
-        [TestMethod]
-		public void RejectTest ()
-		{
-			int res = -1;
-			Exception err = null;
-
-			var p = new Promise<int> ();
-			p.Then (x => res = x, e => err = e);
-			p.Reject (new ApplicationException ("error"));
-
-			Assert.AreEqual (res, -1);
-			Assert.AreEqual (err.Message, "error");
-
+        [TestMethod]
+		public void RejectTest ()
+		{
+			int res = -1;
+			Exception err = null;
+
+			var p = new Promise<int> ();
+			p.Then (x => res = x, e => err = e);
+			p.Reject (new ApplicationException ("error"));
+
+			Assert.AreEqual (res, -1);
+			Assert.AreEqual (err.Message, "error");
+
 		}
 
-        [TestMethod]
-		public void JoinSuccessTest ()
-		{
-			var p = new Promise<int> ();
-			p.Resolve (100);
-			Assert.AreEqual (p.Join (), 100);
+        [TestMethod]
+		public void JoinSuccessTest ()
+		{
+			var p = new Promise<int> ();
+			p.Resolve (100);
+			Assert.AreEqual (p.Join (), 100);
 		}
 
-        [TestMethod]
-		public void JoinFailTest ()
-		{
-			var p = new Promise<int> ();
-			p.Reject (new ApplicationException ("failed"));
-
-			try {
-				p.Join ();
-				throw new ApplicationException ("WRONG!");
-			} catch (TargetInvocationException err) {
-				Assert.AreEqual (err.InnerException.Message, "failed");
-			} catch {
-				Assert.Fail ("Got wrong excaption");
-			}
+        [TestMethod]
+		public void JoinFailTest ()
+		{
+			var p = new Promise<int> ();
+			p.Reject (new ApplicationException ("failed"));
+
+			try {
+				p.Join ();
+				throw new ApplicationException ("WRONG!");
+			} catch (TargetInvocationException err) {
+				Assert.AreEqual (err.InnerException.Message, "failed");
+			} catch {
+				Assert.Fail ("Got wrong excaption");
+			}
 		}
 
-        [TestMethod]
-		public void MapTest ()
-		{
-			var p = new Promise<int> ();
-
-			var p2 = p.Map (x => x.ToString ());
-			p.Resolve (100);
-
-			Assert.AreEqual (p2.Join (), "100");
+        [TestMethod]
+		public void MapTest ()
+		{
+			var p = new Promise<int> ();
+
+			var p2 = p.Map (x => x.ToString ());
+			p.Resolve (100);
+
+			Assert.AreEqual (p2.Join (), "100");
 		}
 
-        [TestMethod]
-		public void ChainTest ()
-		{
-			var p1 = new Promise<int> ();
-
-			var p3 = p1.Chain (x => {
-				var p2 = new Promise<string> ();
-				p2.Resolve (x.ToString ());
-				return p2;
-			});
-
-			p1.Resolve (100);
-
-			Assert.AreEqual (p3.Join (), "100");
+        [TestMethod]
+		public void ChainTest ()
+		{
+			var p1 = new Promise<int> ();
+
+			var p3 = p1.Chain (x => {
+				var p2 = new Promise<string> ();
+				p2.Resolve (x.ToString ());
+				return p2;
+			});
+
+			p1.Resolve (100);
+
+			Assert.AreEqual (p3.Join (), "100");
 		}
 
-        [TestMethod]
-		public void PoolTest ()
-		{
-			var pid = Thread.CurrentThread.ManagedThreadId;
-			var p = AsyncPool.Invoke (() => {
-				return Thread.CurrentThread.ManagedThreadId;
-			});
-
-			Assert.AreNotEqual (pid, p.Join ());
-		}
-	}
-}
-
+        [TestMethod]
+		public void PoolTest ()
+		{
+			var pid = Thread.CurrentThread.ManagedThreadId;
+			var p = AsyncPool.Invoke (() => {
+				return Thread.CurrentThread.ManagedThreadId;
+			});
+
+			Assert.AreNotEqual (pid, p.Join ());
+		}
+	}
+}
+
diff --git a/Implab.sln b/Implab.sln
--- a/Implab.sln
+++ b/Implab.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Implab", "Implab\Implab.csproj", "{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Implab", "Implab\Implab.csproj", "{F550F1F8-8746-4AD0-9614-855F4C4B7F05}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{CE8D8D18-437A-445C-B662-4C2CE79A76F6}"
 	ProjectSection(SolutionItems) = preProject
@@ -23,10 +23,10 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F550F1F8-8746-4AD0-9614-855F4C4B7F05}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F550F1F8-8746-4AD0-9614-855F4C4B7F05}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F550F1F8-8746-4AD0-9614-855F4C4B7F05}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F550F1F8-8746-4AD0-9614-855F4C4B7F05}.Release|Any CPU.Build.0 = Release|Any CPU
 		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Release|Any CPU.ActiveCfg = Release|Any CPU
diff --git a/Implab.suo b/Implab.suo
index 5ef9f84caa1609b501f07d62659a5c03f93635a0..203e41ed2a3711da61caa28207d1625fb6bf3ecb
GIT binary patch
literal 27136
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

diff --git a/Implab/Implab.csproj b/Implab/Implab.csproj
--- a/Implab/Implab.csproj
+++ b/Implab/Implab.csproj
@@ -5,7 +5,7 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProductVersion>10.0.0</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</ProjectGuid>
+    <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
     <OutputType>Library</OutputType>
     <RootNamespace>Implab</RootNamespace>
     <AssemblyName>Implab</AssemblyName>