internal ReverseInheritProperty(
     DependencyPropertyKey flagKey,
     CoreFlags flagCache,
     CoreFlags flagChanged)
     : this(flagKey, flagCache, flagChanged, CoreFlags.None, CoreFlags.None)
 {
 }

        /// <summary>
        /// Clears the local value of the read only property.
        /// </summary>
        /// <param name="element">The element to clear the value to.</param>
        /// <param name="key">The key for the dependency property to be cleared.</param>
        public static void ClearValue(this DependencyObject element, DependencyPropertyKey key)
        {
            if (key == null)
                return;

            try
            {
                readonlyDPThatCanBeChanged.Add(key.DependencyProperty);
                if (element != null)
                    element.ClearValue(key.DependencyProperty);
            }
            finally
            {
                readonlyDPThatCanBeChanged.Remove(key.DependencyProperty);
            }
        }

 private static void VerifyReadOnlyProperty(DependencyProperty dependencyProperty, DependencyPropertyKey dependencyPropertyKey)
 {
     if (dependencyProperty.IsReadOnly &&
         (dependencyPropertyKey == null || dependencyPropertyKey.DependencyProperty != dependencyProperty || !DependencyProperty.IsValidReadOnlyKey(dependencyPropertyKey)))
     {
         throw new Granular.Exception("Can't modify the read-only dependency property \"{0}\" without its key", dependencyProperty);
     }
 }

		public void OverrideMetadata (Type forType, PropertyMetadata typeMetadata, DependencyPropertyKey key)
		{
			if (forType == null)
				throw new ArgumentNullException ("forType");
			if (typeMetadata == null)
				throw new ArgumentNullException ("typeMetadata");


			// further checking?  should we check
			// key.DependencyProperty == this?

			typeMetadata.DoMerge (DefaultMetadata, this, forType);
			metadataByType.Add (forType, typeMetadata);
		}

 [FriendAccessAllowed] // Built into Base, also used by Core and Framework. 
 internal void SetValue(DependencyPropertyKey dp, bool value)
 {
     SetValue(dp, MS.Internal.KnownBoxes.BooleanBoxes.Box(value));
 } 

        /// <summary> 
        ///     Called by SetValue or ClearValue to verify that the property
        /// can be changed. 
        /// </summary> 
        private PropertyMetadata SetupPropertyChange(DependencyPropertyKey key, out DependencyProperty dp)
        { 
            if ( key != null )
            {
                dp = key.DependencyProperty;
 
                if ( dp != null )
                { 
                    dp.VerifyReadOnlyKey(key); 

                    // Get type-specific metadata for this property 
                    return dp.GetMetadata(DependencyObjectType);
                }
                else
                { 
                    throw new ArgumentException(SR.Get(SRID.ReadOnlyKeyNotAuthorized, dp.Name));
                } 
            } 
            else
            { 
                throw new ArgumentNullException("key");
            }
        }

 public bool ContainsValue(DependencyPropertyKey dependencyPropertyKey)
 {
     return ContainsValue(dependencyPropertyKey.DependencyProperty);
 }

 private void SafeSetValue(DependencyPropertyKey property, object value) {
     if (Dispatcher.CheckAccess()) {
         SetValue(property, value);
     } else {
         Dispatcher.BeginInvoke((Action)(() => SetValue(property, value)));
     }
 }

        private void ClearValue(DependencyProperty dependencyProperty, DependencyPropertyKey dependencyPropertyKey, BaseValueSource source)
        {
            VerifyReadOnlyProperty(dependencyProperty, dependencyPropertyKey);

            IDependencyPropertyValueEntry entry;
            if (!entries.TryGetValue(dependencyProperty, out entry))
            {
                return;
            }

            IExpression expression = entry.GetBaseValue((int)source, false) as IExpression;
            if (expression is IDisposable)
            {
                ((IDisposable)expression).Dispose();
            }

            entry.ClearBaseValue((int)source);
            entry.ClearCurrentValue();
        }

        private void SetValue(DependencyProperty dependencyProperty, DependencyPropertyKey dependencyPropertyKey, object value, bool setCurrentValue = false, BaseValueSource source = BaseValueSource.Unknown)
        {
            VerifyReadOnlyProperty(dependencyProperty, dependencyPropertyKey);

            IExpressionProvider newExpressionProvider = value as IExpressionProvider;
            if (newExpressionProvider == null && !dependencyProperty.IsValidValue(value))
            {
                return; // invalid value
            }

            IDependencyPropertyValueEntry entry = GetInitializedValueEntry(dependencyProperty);

            IExpression oldExpression = setCurrentValue ?
                entry.GetBaseValue(false) as IExpression : // current value may be set in the top priority expression
                entry.GetBaseValue((int)source, false) as IExpression;

            if (newExpressionProvider != null)
            {
                value = newExpressionProvider.CreateExpression(this, dependencyProperty);
            }
            else if (oldExpression != null && oldExpression.SetValue(value))
            {
                return; // value (current or not) was set in the existing expression, nothing else to do
            }

            if (setCurrentValue)
            {
                entry.SetCurrentValue(value);
                return; // base value isn't changed
            }

            if (oldExpression is IDisposable) // expression is being replaced
            {
                ((IDisposable)oldExpression).Dispose();
            }

            entry.SetBaseValue((int)source, value);
            entry.ClearCurrentValue();
        }

        /// <summary> 
        ///     Clears the local value of a property
        /// </summary> 
        public void ClearValue(DependencyPropertyKey key) 
        {
            // Do not allow foreign threads to clear properties. 
            // (This is a noop if this object is not assigned to a Dispatcher.)
            //
            this.VerifyAccess();
 
            DependencyProperty dp;
 
            // Cache the metadata object this method needed to get anyway. 
            PropertyMetadata metadata = SetupPropertyChange(key, out dp);
 
            EntryIndex entryIndex = LookupEntry(dp.GlobalIndex);

            ClearValueCommon(entryIndex, dp, metadata);
        } 

        static ContentControl3D()
        {
            DefaultStyleKeyProperty.OverrideMetadata(
                typeof (ContentControl3D),
                new FrameworkPropertyMetadata(typeof (ContentControl3D)));

            AnimationLengthProperty =
                DependencyProperty.Register(
                    "AnimationLength",
                    typeof (int),
                    typeof (ContentControl3D),
                    new UIPropertyMetadata(600, OnAnimationLengthChanged));

            BackContentProperty = DependencyProperty.Register(
                "BackContent",
                typeof (object),
                typeof (ContentControl3D));

            BackContentTemplateProperty = DependencyProperty.Register(
                "BackContentTemplate",
                typeof (DataTemplate),
                typeof (ContentControl3D),
                new UIPropertyMetadata(null));

            IsFrontInViewPropertyKey = DependencyProperty.RegisterReadOnly(
                "IsFrontInView",
                typeof (bool),
                typeof (ContentControl3D),
                new UIPropertyMetadata(true));
            IsFrontInViewProperty = IsFrontInViewPropertyKey.DependencyProperty;
        }

        static TransitionControl()
        {
            DefaultStyleKeyProperty.OverrideMetadata(
            typeof(TransitionControl),
            new FrameworkPropertyMetadata(typeof(TransitionControl)));

            TransitionEffectProperty = DependencyProperty.Register(
               "TransitionEffect",
               typeof(TransitionEffects),
               typeof(TransitionControl),
               new FrameworkPropertyMetadata(TransitionEffects.None));

            StaleContentProperty = DependencyProperty.Register(
            "StaleContent",
            typeof(Object),
            typeof(TransitionControl),
            new FrameworkPropertyMetadata(null));

            ContentControl.ContentProperty.OverrideMetadata(
            typeof(TransitionControl),
            new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnContentChanged)));

            IsContentChangedPropertyKey = DependencyProperty.RegisterReadOnly(
               "IsContentChanged",
               typeof(Boolean),
               typeof(TransitionControl),
               new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));

            IsContentChangedProperty = IsContentChangedPropertyKey.DependencyProperty;
        }

 static WaitIndicator() {
     Type ownerType = typeof(WaitIndicator);
     DeferedVisibilityProperty = DependencyProperty.Register("DeferedVisibility", typeof(bool), ownerType, new PropertyMetadata(false, OnDeferedVisibilityPropertyChanged));
     ShowShadowProperty = DependencyProperty.Register("ShowShadow", typeof(bool), ownerType, new PropertyMetadata(true));
     ContentPaddingProperty = DependencyProperty.Register("ContentPadding", typeof(Thickness), ownerType, new PropertyMetadata(new Thickness()));
     ActualContentPropertyKey = DependencyProperty.RegisterReadOnly("ActualContent", typeof(object), ownerType, new FrameworkPropertyMetadata(null));
     ActualContentProperty = ActualContentPropertyKey.DependencyProperty;
 }

 /// <summary>
 /// Initializes static members of the LicensePage class.
 /// </summary>
 static LicensePage()
 {
     _MustBeShownPropertyKey = DependencyProperty.RegisterReadOnly(
         "MustBeShown",
         typeof(bool),
         typeof(LicensePage),
         new PropertyMetadata(false));
     MustBeShownProperty = _MustBeShownPropertyKey.DependencyProperty;
 }

        static AutoHideChannel()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(AutoHideChannel), new FrameworkPropertyMetadata(typeof(AutoHideChannel)));

            //Register Dependency Properties
            ChannelWidthProperty = DependencyProperty.RegisterReadOnly("ChannelWidth", typeof(double), typeof(AutoHideChannel), new UIPropertyMetadata(0d));
            ChannelHeightProperty = DependencyProperty.RegisterReadOnly("ChannelHeight", typeof(double), typeof(AutoHideChannel), new UIPropertyMetadata(0d));
            CurrentWindowViewProperty = DependencyProperty.RegisterReadOnly("CurrentWindowView", typeof(View), typeof(AutoHideChannel), new UIPropertyMetadata(null));
        }

 static FormulaControl()
 {
     var registator = new DependencyPropertyRegistator<FormulaControl>();
     FormulaProperty = registator.Register<string>("Formula", propertyChanged:FormulaChanged, coerceValueCallback:OnFormulaCoerceCallback);
     FormulaVisualPropertyKey = registator.RegisterReadOnly<DrawingVisual>("FormulaVisual");
     EditableNowPropertyKey = registator.RegisterReadOnly<bool>("EditableNow");
     FormulaVisualProperty = FormulaVisualPropertyKey.DependencyProperty;
     EditableNowProperty = EditableNowPropertyKey.DependencyProperty;
 }

 static AlignPart()
 {
     AlignedPartsPropertyKey = DependencyProperty.RegisterReadOnly("AlignedParts", typeof(PartRefSet), typeof(AlignPart),
         new PropertyMetadata(default(PartRefSet),
         (o, e) =>
         {
             var _this = (AlignPart)o;
             //_this.CoerceValue(dps.TextProperty);
         }));
 }

        static TransitionPresenter()
        {
            FrameworkElement.DefaultStyleKeyProperty.OverrideMetadata(
                typeof(TransitionPresenter), new FrameworkPropertyMetadata(typeof(TransitionPresenter)));

            //Registering RoutedEvents and Dependency Properties
            PreviousTransitionStartedEvent = EventManager.RegisterRoutedEvent("PreviousTransitionStarted", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(TransitionPresenter));
            PreviousTransitionEndedEvent = EventManager.RegisterRoutedEvent("PreviousTransitionEnded", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(TransitionPresenter));
            NextTransitionStartedEvent = EventManager.RegisterRoutedEvent("NextTransitionStarted", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(TransitionPresenter));
            NextTransitionEndedEvent = EventManager.RegisterRoutedEvent("NextTransitionEnded", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(TransitionPresenter));
            IsSelectTransitionRunningPropertyKey = DependencyProperty.RegisterReadOnly("IsSelectTransitionRunning", typeof(bool), typeof(TransitionPresenter), new FrameworkPropertyMetadata(false, new PropertyChangedCallback(TransitionPresenter.OnIsSelectTransitionRunningChanged)));
            IsSelectTransitionRunningProperty = IsSelectTransitionRunningPropertyKey.DependencyProperty;
        }

		static DragDropViewInfo() {
			Type ownerType = typeof(DragDropViewInfo);
			DraggingRowsPropertyKey = DependencyPropertyManager.RegisterReadOnly("DraggingRows", typeof(IList), ownerType, new UIPropertyMetadata(null));
			DraggingRowsProperty = DraggingRowsPropertyKey.DependencyProperty;
			DropTargetTypePropertyKey = DependencyPropertyManager.RegisterReadOnly("DropTargetType", typeof(DropTargetType), ownerType, new UIPropertyMetadata(DropTargetType.None));
			DropTargetTypeProperty = DropTargetTypePropertyKey.DependencyProperty;
			DropTargetRowPropertyKey = DependencyPropertyManager.RegisterReadOnly("DropTargetRow", typeof(object), ownerType, new UIPropertyMetadata(null));
			DropTargetRowProperty = DropTargetRowPropertyKey.DependencyProperty;
			GroupInfoPropertyKey = DependencyPropertyManager.RegisterReadOnly("GroupInfo", typeof(IList<GroupInfo>), ownerType, new UIPropertyMetadata(null));
			GroupInfoProperty = GroupInfoPropertyKey.DependencyProperty;
			FirstDraggingObjectPropertyKey = DependencyPropertyManager.RegisterReadOnly("FirstDraggingObject", typeof(object), ownerType, new UIPropertyMetadata(null));
			FirstDraggingObjectProperty = FirstDraggingObjectPropertyKey.DependencyProperty;
		}