/// <summary>
 /// AxisLabelStyleProperty property changed handler.
 /// </summary>
 /// <param name="d">DisplayAxis that changed its AxisLabelStyle.</param>
 /// <param name="e">Event arguments.</param>
 private static void OnAxisLabelStylePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     DisplayAxis source = (DisplayAxis)d;
     Style oldValue = (Style)e.OldValue;
     Style newValue = (Style)e.NewValue;
     source.OnAxisLabelStylePropertyChanged(oldValue, newValue);
 }

 /// <summary>
 /// RatioVisibleProperty property changed handler.
 /// </summary>
 /// <param name="d">PartialView that changed its RatioVisible.</param>
 /// <param name="e">Event arguments.</param>
 private static void OnRatioVisibleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     Clipper source = (Clipper)d;
     double oldValue = (double)e.OldValue;
     double newValue = (double)e.NewValue;
     source.OnRatioVisibleChanged(oldValue, newValue);
 }

 private static void OnTriggersChanged(IDependencyObject obj, DependencyPropertyChangedEventArgs args)
 {
     var triggerCollection1 = args.OldValue as TriggerCollection;
     var triggerCollection2 = args.NewValue as TriggerCollection;
     if (triggerCollection1 == triggerCollection2)
     {
         return;
     }
     if (triggerCollection1 != null && triggerCollection1.AssociatedObject != null)
     {
         triggerCollection1.Detach();
     }
     if (triggerCollection2 == null || obj == null)
     {
         return;
     }
     if (triggerCollection2.AssociatedObject != null)
     {
         throw new InvalidOperationException("Cannot attach TriggerCollection multiple imes");
     }
     var fElement = obj as FormElement;
     if (fElement == null)
     {
         throw new InvalidOperationException("Can only host TriggerCollection on FormElement");
     }
     triggerCollection2.Attach(fElement);
 }

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

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


            target.PropertyChanged(MatrixProperty);
        }

 /// <summary>
 /// LocationProperty property changed handler.
 /// </summary>
 /// <param name="d">Axis that changed its Location.</param>
 /// <param name="e">Event arguments.</param>
 private static void OnLocationPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     Axis source = (Axis)d;
     AxisLocation oldValue = (AxisLocation)e.OldValue;
     AxisLocation newValue = (AxisLocation)e.NewValue;
     source.OnLocationPropertyChanged(oldValue, newValue);
 }

        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);
        }

 private static void OnAttachChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     Action<System.Windows.Interactivity.TriggerBase> action = null;
     System.Windows.Interactivity.TriggerCollection allTriggers;
     if (e.NewValue != e.OldValue)
     {
         System.Windows.Interactivity.TriggerBase[] enumerable = (System.Windows.Interactivity.TriggerBase[]) d.GetValue(MessageTriggersProperty);
         allTriggers = Interaction.GetTriggers(d);
         if (enumerable != null)
         {
             if (action == null)
             {
                 action = (Action<System.Windows.Interactivity.TriggerBase>) (x => allTriggers.Remove(x));
             }
             enumerable.Apply<System.Windows.Interactivity.TriggerBase>(action);
         }
         System.Windows.Interactivity.TriggerBase[] baseArray2 = Parser.Parse(d, e.NewValue as string).ToArray<System.Windows.Interactivity.TriggerBase>();
         baseArray2.Apply<System.Windows.Interactivity.TriggerBase>(new Action<System.Windows.Interactivity.TriggerBase>(allTriggers.Add));
         if (baseArray2.Length > 0)
         {
             d.SetValue(MessageTriggersProperty, baseArray2);
         }
         else
         {
             d.ClearValue(MessageTriggersProperty);
         }
     }
 }

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

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

        private static void ViewMatrixPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            MatrixCamera target = ((MatrixCamera) d); 
 

            target.PropertyChanged(ViewMatrixProperty); 
        }

 private static void OnIsSelectedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     BarPiece source = (BarPiece)d;
     bool oldValue = (bool)e.OldValue;
     bool newValue = (bool)e.NewValue;
     source.OnIsSelectedPropertyChanged(oldValue, newValue);
 }

        /// <summary> 
        /// IsDraggingProperty property changed handler.
        /// </summary> 
        /// <param name="d">Thumb that changed IsDragging.</param>
        /// <param name="e">DependencyPropertyChangedEventArgs.</param>
        private static void OnIsDraggingPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Thumb thumb = d as Thumb;
            Debug.Assert(thumb != null); 
 
            thumb.OnDraggingChanged();
        } 

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

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


            target.PropertyChanged(ColorProperty);
        }

 /// <summary>
 /// ExpandDirectionProperty property changed handler.
 /// </summary>
 /// <param name="d">ExpandDirectionView that changed its ExpandDirection.</param>
 /// <param name="e">Event arguments.</param>
 private static void OnExpandDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     LinearClipper source = (LinearClipper)d;
     ExpandDirection oldValue = (ExpandDirection)e.OldValue;
     ExpandDirection newValue = (ExpandDirection)e.NewValue;
     source.OnExpandDirectionChanged(oldValue, newValue);
 }

 private static void OnIsSelecedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     var control = d as BigTabBarItem;
     if (control == null || e.NewValue == null || e.NewValue == e.OldValue) return;
     string state = (bool.Parse(e.NewValue.ToString())) ? "Selected" : "Unselected";
     VisualStateManager.GoToState(control, state, true);            
 }

        private static void OnTargetChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue == null || obj == null)
                return;

            EditorAdapterBase target = e.NewValue as EditorAdapterBase;
            EditorAdapterBase oldTarget = e.OldValue as EditorAdapterBase;
            CompletionPopupView view = obj as CompletionPopupView;

            EventHandler selectionChanged = (sender, args) => view.Publish(new SelectionChangedEvent(target.CaretIndex));
            KeyEventHandler previewKeyDown = (sender, args) => view.Publish(new CancellableKeyEvent(args, EventSource.Editor));
            KeyEventHandler keyUp = (sender, args) => view.Publish(new KeyUpEvent(args, EventSource.Editor));
            KeyEventHandler keyDown = (sender, args) => view.Publish(new KeyEvent(args, EventSource.Editor));

            if (target != null)
            {
                target.SelectionChanged += selectionChanged;
                target.PreviewKeyDown += previewKeyDown;
                target.KeyDown += keyDown;
                target.KeyUp += keyUp;
            }

            if (oldTarget != null)
            {
                oldTarget.SelectionChanged -= selectionChanged;
                target.PreviewKeyDown -= previewKeyDown;
                target.KeyDown -= keyDown;
                target.KeyUp -= keyUp;
            }
        }

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

        private static void FieldOfViewPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            PerspectiveCamera target = ((PerspectiveCamera) d);


            target.PropertyChanged(FieldOfViewProperty);
        }

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

        static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
            var parameter = (Parameter)d;

            if (parameter.Owner != null) {
                parameter.Owner.UpdateAvailability();
            }
        }

        /// <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); 
        }