public static void SetBinding ( 
			DependencyObject target, 
			DependencyProperty property,
			Binding binding ) {

			throw new NotImplementedException ( );
		}

 /// <summary>
 /// Handles the <see cref="Mouse.PreviewMouseDownEvent"/>.
 /// </summary>
 private static void HandlePreviewMouseDown(DependencyObject element, MouseDevice device, MouseButton button, ref RoutedEventData data)
 {
     if (button == MouseButton.Left)
     {
         ((SliderBase)element).Focus();
     }
 }

        /// <summary>
        /// Parses the specified message text.
        /// </summary>
        /// <param name="target">The target.</param>
        /// <param name="text">The message text.</param>
        /// <returns>The triggers parsed from the text.</returns>
        public static IEnumerable<TriggerBase> Parse(DependencyObject target, string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return new TriggerBase[0];
            }

            var triggers = new List<TriggerBase>();
            var messageTexts = Split(text, ';');

            foreach (var messageText in messageTexts)
            {
                var triggerPlusMessage = LongFormatRegularExpression.IsMatch(messageText)
                                             ? Split(messageText, '=')
                                             : new[] { null, messageText };

                var messageDetail = triggerPlusMessage.Last()
                    .Replace("[", string.Empty)
                    .Replace("]", string.Empty)
                    .Trim();

                var trigger = CreateTrigger(target, triggerPlusMessage.Length == 1 ? null : triggerPlusMessage[0]);
                var message = CreateMessage(target, messageDetail);

                trigger.Actions.Add(message);
                triggers.Add(trigger);
            }

            return triggers;
        }

        private static void OnBehaviorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var oldBehaviorCollection = (BehaviorCollection)e.OldValue;
            var newBehaviorCollection = (BehaviorCollection)e.NewValue;

            if (oldBehaviorCollection == newBehaviorCollection)
            {
                return;
            }

            if (oldBehaviorCollection != null)
            {
#if WINDOWS_PHONE
                var associatedObject = typeof(BehaviorCollection)
                    .GetProperty("AssociatedObject", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                    .GetValue(oldBehaviorCollection);
#else
                var associatedObject = oldBehaviorCollection.AssociatedObject;
#endif
                if (associatedObject != null)
                {
                    oldBehaviorCollection.Detach();
                }
            }

            if (newBehaviorCollection == null || d == null)
            {
                return;
            }

            newBehaviorCollection.Attach(d);
        }

        /// <summary>
        /// Adds a handler for the PreviewAxisChanged attached event to the specified element.
        /// </summary>
        /// <param name="element">The element to which to add the handler.</param>
        /// <param name="handler">The handler to add to the specified element.</param>
        public static void AddPreviewAxisChangedHandler(DependencyObject element, UpfGamePadAxisChangedEventHandler handler)
        {
            Contract.Require(element, "element");
            Contract.Require(handler, "handler");

            IInputElementHelper.AddHandler(element, PreviewAxisChangedEvent, handler);
        }

        //------------------------------------------------------ 
        //
        //  Public Properties 
        //
        //-----------------------------------------------------

        private static void PositionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            PointLightBase target = ((PointLightBase) d); 
 

            target.PropertyChanged(PositionProperty); 
        }

        /// <summary>
        /// Handles changes to the MenuFlyout DependencyProperty.
        /// </summary>
        /// <param name="o">DependencyObject that changed.</param>
        /// <param name="e">Event data for the DependencyPropertyChangedEvent.</param>
        private static void OnMenuFlyoutChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            var element = o as FrameworkElement;

            if (null != element)
            {
                // just in case we were here before and there is no new menu
                element.Holding -= OnElementHolding;

                MenuFlyout oldMenuFlyout = e.OldValue as MenuFlyout;

                if (null != oldMenuFlyout)
                {
                    // Remove previous attachment
                    element.SetValue(FlyoutBase.AttachedFlyoutProperty, null);
                }

                MenuFlyout newMenuFlyout = e.NewValue as MenuFlyout;

                if (null != newMenuFlyout)
                {
                    // attach using FlyoutBase to easier show the menu
                    element.SetValue(FlyoutBase.AttachedFlyoutProperty, newMenuFlyout);

                    // need to show it
                    element.Holding += OnElementHolding;
                }
            }
        }

        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------

        private static void DirectionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            DirectionalLight target = ((DirectionalLight) d);


            target.PropertyChanged(DirectionProperty);
        }

 /// <summary>
 /// MinimumDistanceBetweenChildrenProperty property changed handler.
 /// </summary>
 /// <param name="d">OrientedPanel that changed its MinimumDistanceBetweenChildren.</param>
 /// <param name="e">Event arguments.</param>
 private static void OnMinimumDistanceBetweenChildrenPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     OrientedPanel source = (OrientedPanel)d;
     double oldValue = (double)e.OldValue;
     double newValue = (double)e.NewValue;
     source.OnMinimumDistanceBetweenChildrenPropertyChanged(oldValue, newValue);
 }

 public VisualTreeChangeEventArgs(DependencyObject parent, DependencyObject child, int childIndex, VisualTreeChangeType changeType)
 {
     Parent = parent;
     Child = child;
     ChildIndex = childIndex;
     ChangeType = changeType;
 }

        /// <summary>
        ///     Called when HeaderProperty is invalidated on "d." 
        /// </summary> 
        private static void OnHeaderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            HeaderedItemsControl ctrl = (HeaderedItemsControl) d;

            ctrl.SetValue(HasHeaderPropertyKey, (e.NewValue != null) ? BooleanBoxes.TrueBox : BooleanBoxes.FalseBox);
            ctrl.OnHeaderChanged(e.OldValue, e.NewValue); 
        }

		static void CheckTarget (DependencyObject target)
		{
			if (target == null)
				throw new ArgumentNullException ("target");
			if (!(target is TextBox))
				throw new ArgumentException ("target is not a TextBox", "target");
		}

 private static void OnSizePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     PredefinedMarkerStyle style = d as PredefinedMarkerStyle;
     style.OnPropertyChanged("Size");
     style.OnPropertyChanged("OffsetX");
     style.OnPropertyChanged("OffsetY");
 }

        /// <summary>
        /// Removes a handler for the GenericInteraction attached event to the specified element.
        /// </summary>
        /// <param name="element">The element from which to remove the handler.</param>
        /// <param name="handler">The handler to remove from the specified element.</param>
        public static void RemoveGenericInteractionHandler(DependencyObject element, UpfTouchTapEventHandler handler)
        {
            Contract.Require(element, "element");
            Contract.Require(handler, "handler");

            IInputElementHelper.RemoveHandler(element, GenericInteractionEvent, handler);
        }

        /// <summary>
        /// Adds a handler for the PreviewGenericInteraction attached event to the specified element.
        /// </summary>
        /// <param name="element">The element to which to add the handler.</param>
        /// <param name="handler">The handler to add to the specified element.</param>
        public static void AddPreviewTapHandler(DependencyObject element, UpfGenericInteractionEventHandler handler)
        {
            Contract.Require(element, "element");
            Contract.Require(handler, "handler");

            IInputElementHelper.AddHandler(element, PreviewGenericInteractionEvent, handler);
        }

        private static void OnOtherContentTemplatePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var panControl = d as PanControl;
            if (panControl == null) return;

            panControl.OnOtherContentTemplateChanged((DataTemplate)e.OldValue, (DataTemplate)e.NewValue);
        }

        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------

        private static void ColorPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            EmissiveMaterial target = ((EmissiveMaterial) d);


            target.PropertyChanged(ColorProperty);
        }

        static void ModelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (Execute.InDesignMode || e.NewValue == null || e.NewValue == e.OldValue)
            {
                return;
            }

            var fe = d as FrameworkElement;
            if (fe == null)
            {
                return;
            }

            View.ExecuteOnLoad(fe, delegate
            {
                var target = e.NewValue;
                var containerKey = e.NewValue as string;

                if (containerKey != null)
                {
                    target = IoC.GetInstance(null, containerKey);
                }

                d.SetValue(View.IsScopeRootProperty, true);

                var context = string.IsNullOrEmpty(fe.Name)
                                  ? fe.GetHashCode().ToString()
                                  : fe.Name;

                ViewModelBinder.Bind(target, d, context);
            });
        }

        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------

        private static void MatrixPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            MatrixTransform3D target = ((MatrixTransform3D) d);


            target.PropertyChanged(MatrixProperty);
        }

        private static void OnMapPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ZoomSlider zs = d as ZoomSlider;
            Map newValue = e.NewValue as Map;
            Map oldValue = e.OldValue as Map;

            if (oldValue != null)
            {
                oldValue.ViewBoundsChanged -= new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanged);
                oldValue.ViewBoundsChanging -= new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanging);
                if (oldValue.Layers != null)
                {
                    oldValue.Layers.LayersInitialized -= new EventHandler(zs.Layers_LayersInitialized);
                }
                newValue.ResolutionsChanged -= new EventHandler<ResolutionsEventArgs>(zs.newValue_ResolutionsChanged);

            }

            if (newValue != null)
            {
                newValue.ViewBoundsChanged += new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanged);
                newValue.ViewBoundsChanging += new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanging);
                if (newValue.Layers != null)
                {
                    newValue.Layers.LayersInitialized += new EventHandler(zs.Layers_LayersInitialized);
                }
                //后设置Map的Scales也要起作用。
                newValue.ResolutionsChanged += new EventHandler<ResolutionsEventArgs>(zs.newValue_ResolutionsChanged);
            }
        }