/// 
        /// <summary>
        /// Helper to create double animation</summary>
        /// 
        public static Storyboard AddDouble(
            this Storyboard                             sb,
            int                                         durationMs,
            DependencyObject                            element,
            PropertyPath                                path,
            double                                      from,
            double                                      to,
            IEasingFunction                             easing = null
        )
        {
            DoubleAnimation                             da;

            da = new DoubleAnimation();
            da.Duration = new Duration(TimeSpan.FromMilliseconds(durationMs));

            da.From = from;
            da.To =  to;

            if (easing != null)
            {
                da.EasingFunction = easing;
            }

            Storyboard.SetTarget(da, element);
            Storyboard.SetTargetProperty(da, path);

            sb.Children.Add(da);
            return sb;
        }

		public void PropertyPathCtors ()
		{
			PropertyPath prop;
			
			Assert.Throws <ArgumentOutOfRangeException>(() =>
				prop = new PropertyPath ("first", "second")
			, "#1");
			
			Assert.Throws<ArgumentOutOfRangeException>(delegate {
				prop = new PropertyPath (null, "arg1");
			}, "null path throws ArgumentOutOfRangeException");
			
			prop = new PropertyPath (Rectangle.WidthProperty);
			Assert.AreEqual ("(0)", prop.Path, "Normal PropertyPath");
			
			prop = new PropertyPath (Canvas.LeftProperty);
			Assert.AreEqual ("(0)", prop.Path, "Attached PropertyPath");
			
			prop = new PropertyPath (5);
			Assert.IsNull (prop.Path, "numeric PropertyPath is null");

			Assert.Throws<NullReferenceException> (delegate {
				prop = new PropertyPath (null, null);
			}, "Both null");

			Assert.Throws<NullReferenceException> (delegate {
				prop = new PropertyPath ("pathstring", null);
			}, "second null");

			prop = new PropertyPath ((string) null);
			Assert.IsNull (prop.Path, "null PropertyPath is null");
		}

        public static Task SmoothSetAsync(this FrameworkElement @this, DependencyProperty dp, double targetvalue,
            TimeSpan iDuration, CancellationToken iCancellationToken)
        {
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            DoubleAnimation anim = new DoubleAnimation(targetvalue, new Duration(iDuration));
            PropertyPath p = new PropertyPath("(0)", dp);
            Storyboard.SetTargetProperty(anim, p);
            Storyboard sb = new Storyboard();
            sb.Children.Add(anim);
            EventHandler handler = null;
            handler = delegate
            {
                sb.Completed -= handler;
                sb.Remove(@this);
                @this.SetValue(dp, targetvalue);
                tcs.TrySetResult(null);
            };
            sb.Completed += handler;
            sb.Begin(@this, true);

            iCancellationToken.Register(() =>
            {
                double v = (double)@this.GetValue(dp);  
                sb.Stop(); 
                sb.Remove(@this); 
                @this.SetValue(dp, v);
                tcs.TrySetCanceled();
            });

            return tcs.Task;
        }

 private static Type GetTypeFromName (PropertyPath propertyPath, string name)
 {
     // HACK
     return (Type)typeof(PropertyPath)
         .GetMethod("GetTypeFromName", BindingFlags.Instance | BindingFlags.NonPublic)
         .Invoke(propertyPath, new object[] { name, null });
 }

        public static Storyboard CreateAnim(DependencyObject target, EquationType type, TimeSpan duration, PropertyPath property, double from, double to)
        {
            Storyboard sb = new Storyboard();

            AddAnimation(sb, target, property, duration, type, from, to);

            return sb;
        }

 public AnimationInfo(DependencyObject target, PropertyPath propertyPath, double startValue, double endValue, IEasingFunction easingFunction = null)
 {
     Target = target;
       PropertyPath = propertyPath;
       StartValue = startValue;
       EndValue = endValue;
       EasingFunction = easingFunction;
 }

		public virtual Boolean CanCreateCommand( PropertyPath path, DependencyObject target )
		{
			if ( DesignTimeHelper.GetIsInDesignMode() )
			{
				return false;
			}

			return path != null && ( target is FrameworkElement || target is FrameworkContentElement );
		}

 internal static PropertyPath GetPath(DependencyProperty property)
 {
     PropertyPath path;
     if (!PropertyPaths.TryGetValue(property, out path))
     {
         path = new PropertyPath(property);
         PropertyPaths[property] = path;
     }
     return path;
 }

 internal static PropertyPath GetPath(string path)
 {
     PropertyPath propertyPath;
     if (!PropertyPaths.TryGetValue(path, out propertyPath))
     {
         propertyPath = new PropertyPath(path);
         PropertyPaths[path] = propertyPath;
     }
     return propertyPath;
 }

        internal static PropertyPath GetPath(int index)
        {
            PropertyPath path;
            if (!IndexPaths.TryGetValue(index, out path))
            {
                path = new PropertyPath($"[{index}]");
                IndexPaths[index] = path;
            }

            return path;
        }

        PropertyPath PrepareXmlBinding(PropertyPath path)
        {
            if (path == null)
            {
                DependencyProperty targetDP = TargetProperty;
                Type targetType = targetDP.PropertyType;
                string pathString;

                if (targetType == typeof(Object))
                {
                    if (targetDP == System.Windows.Data.BindingExpression.NoTargetProperty ||
                        targetDP == System.Windows.Controls.Primitives.Selector.SelectedValueProperty ||
                        targetDP.OwnerType == typeof(LiveShapingList)
                        )
                    {
                        // these properties want the "value" - i.e. the text of
                        // the first (and usually only) XmlNode
                        pathString = "/InnerText";
                    }
                    else if (targetDP == FrameworkElement.DataContextProperty ||
                              targetDP == CollectionViewSource.SourceProperty)
                    {
                        // these properties want the entire collection
                        pathString = String.Empty;
                    }
                    else
                    {
                        // most object-valued properties want the (current) XmlNode itself
                        pathString = "/";
                    }
                }
                else if (targetType.IsAssignableFrom(typeof(XmlDataCollection)))
                {
                    // these properties want the entire collection
                    pathString = String.Empty;
                }
                else
                {
                    // most other properties want the "value"
                    pathString = "/InnerText";
                }

                path = new PropertyPath(pathString);
            }

            // don't bother to create XmlWorker if we don't even have a valid path
            if (path.SVI.Length > 0)
            {
                // tell Xml Worker if desired result is collection, in order to get optimization
                SetValue(Feature.XmlWorker, new XmlBindingWorker(this, path.SVI[0].drillIn == DrillIn.Never));
            }
            return path;
        }

        public LocBindingTarget(LocalizationInstance loc, FrameworkElement targetObject, PropertyPath path)
        {
            _locInstance = loc;
            _lbCollection.Add(this);
            _path = path;
            
            
            targetObject.DataContextChanged += new DependencyPropertyChangedEventHandler(update_binding);

            update_binding(targetObject, new DependencyPropertyChangedEventArgs(FrameworkElement.DataContextProperty, null, targetObject.DataContext));

        }

		public void SetName ()
		{
			Storyboard sb = new Storyboard ();
			PropertyPath path = new PropertyPath ("Width");
			Storyboard.SetTargetProperty (sb, path);
			PropertyPath native = Storyboard.GetTargetProperty (sb);

			Assert.AreNotEqual (path, native, "#1");
			Assert.IsFalse (path == native, "#2");
			Assert.AreEqual(path.Path, native.Path, "#3");
			Assert.AreEqual (path.Path, "Width", "#4");
		}

        private static PropertyPath GetPath(DependencyProperty property)
        {
            PropertyPath path;
            if (PropertyPaths.TryGetValue(property, out path))
            {
                return path;
            }

            path = new PropertyPath(property);
            PropertyPaths[property] = path;
            return path;
        }

        private PropertyPathWorker(PropertyPath path, DataBindEngine engine)
        {
            _parent = path;
            _arySVS = new SourceValueState[path.Length];
            _engine = engine;

            // initialize each level to NullDataItem, so that the first real
            // item will force a change
            for (int i=_arySVS.Length-1; i>=0; --i)
            {
                _arySVS[i].item = BindingExpression.CreateReference(BindingExpression.NullDataItem);
            }
        }

 public PropertyChangeNotifier(DependencyObject propertySource, PropertyPath property)
 {
     if (null == propertySource)
         throw new ArgumentNullException("propertySource");
     if (null == property)
         throw new ArgumentNullException("property");
     this._propertySource = new WeakReference(propertySource);
     Binding binding = new Binding();
     binding.Path = property;
     binding.Mode = BindingMode.OneWay;
     binding.Source = propertySource;
     BindingOperations.SetBinding(this, ValueProperty, binding);
 }

        /// <summary>
        /// Animates property of a given object over time
        /// </summary>
        /// <param name="sender">Object that will be animated</param>
        /// <param name="value">Value of the property</param>
        /// <param name="milliseconds">Timespan of animation</param>
        /// <param name="property">Targeted property</param>
        public static void Fade(DependencyObject sender, double value, double milliseconds, PropertyPath property)
        {
            Storyboard s = new Storyboard();
            DoubleAnimation da = new DoubleAnimation();
            da.To = value;
            da.Duration = new Duration(TimeSpan.FromMilliseconds(milliseconds));

            Storyboard.SetTarget(da, sender);
            Storyboard.SetTargetProperty(da, property);

            s.Children.Add(da);
            s.Begin();
        }

        public static DoubleAnimation CreateDoubleAnimation(UIElement uiElement, double from, double to, PropertyPath propertyToAnimate)
        {
            DoubleAnimation animation = new DoubleAnimation();

            Storyboard.SetTarget(animation, uiElement);
            Storyboard.SetTargetProperty(animation, propertyToAnimate);

            // Note that the animation applies to the Canvas.Left property
            animation.From = from ;
            animation.To = to ;
            animation.Duration = TimeSpan.FromMilliseconds(100);

            return animation;
        }

 internal static BindingExpression Bind(
     DependencyObject target,
     DependencyProperty targetProperty,
     object source,
     PropertyPath path)
 {
     var binding = new Binding
     {
         Path = path,
         Source = source,
         Mode = BindingMode.OneWay,
         UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
     };
     return (BindingExpression)BindingOperations.SetBinding(target, targetProperty, binding);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MarkupExtension"/> class.
        /// </summary>
        protected MarkupExtension()
        {
            if (CatelEnvironment.IsInDesignMode)
            {
                return;
            }

            Source = this;
            Mode = BindingMode.OneWay;
            Path = new PropertyPath("InternalBindingValue");

#if NETFX_CORE
            Dispatcher.BeginInvoke(UpdateBinding);
#endif
        }