public FunctionalPropertyMetadata(object defaultValue, FunctionalPropertyMetadataOptions flags, PropertyChangedCallback propertyChangedCallback, CoerceValueCallback coerceValueCallback)
 {
     DefaultValue = defaultValue;
     PropertyChangedCallback = propertyChangedCallback;
     CoerceValueCallback = coerceValueCallback;
     _flags = flags;
 }

 public PropertyMetadata(MetadataOption options, PropertyChangedCallback propertyChangedCallback = null,
     CoerceValueCallback coerceValueCallback = null)
 {
     Options = options;
     PropertyChanged = propertyChangedCallback;
     CoerceValue = coerceValueCallback;
 }

 protected override void OnApply(DependencyProperty dp, Type targetType)
 {
     doType = DependencyObjectType.FromSystemType(targetType);
     propertyChangedCallbackInternal = PropertyChangedCallback;
     PropertyChangedCallback = OnPropertyChanged;
     base.OnApply(dp, targetType);
 }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------

        #region Constructors

        /// <summary>
        /// Static constructor for TextBox.
        /// </summary>
        static TextBox()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(typeof(TextBox)));
            _dType = DependencyObjectType.FromSystemTypeInternal(typeof(TextBox));

            // Add handlers for height properties so we can manage min/maxLines
            PropertyChangedCallback callback = new PropertyChangedCallback(OnMinMaxChanged);

            HeightProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(callback));
            MinHeightProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(callback));
            MaxHeightProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(callback));
            FontFamilyProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(callback));
            FontSizeProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(callback));

            // Registering typography properties metadata
            PropertyChangedCallback onTypographyChanged = new PropertyChangedCallback(OnTypographyChanged);
            DependencyProperty[] typographyProperties = Typography.TypographyPropertiesList;
            for (int i = 0; i < typographyProperties.Length; i++)
            {
                typographyProperties[i].OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(onTypographyChanged));
            }

            HorizontalScrollBarVisibilityProperty.OverrideMetadata(typeof(TextBox), new FrameworkPropertyMetadata(
             ScrollBarVisibility.Hidden,
             new PropertyChangedCallback(OnScrollViewerPropertyChanged), // PropertyChangedCallback
             new CoerceValueCallback(CoerceHorizontalScrollBarVisibility)));

        }

 public FrameworkPropertyMetadata(
             PropertyChangedCallback propertyChangedCallback,
             CoerceValueCallback coerceValueCallback)
             : base(propertyChangedCallback)
 {
     this.CoerceValueCallback = coerceValueCallback;
 }

        static CornerRadiusAnimation()
        {
            Type typeofProp = typeof(CornerRadius?);
            Type typeofThis = typeof(CornerRadiusAnimation);
            PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed);
            ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue);

            FromProperty = DependencyProperty.Register(
                "From",
                typeofProp,
                typeofThis,
                new PropertyMetadata((CornerRadius?)null, propCallback),
                validateCallback);

            ToProperty = DependencyProperty.Register(
                "To",
                typeofProp,
                typeofThis,
                new PropertyMetadata((CornerRadius?)null, propCallback),
                validateCallback);

            ByProperty = DependencyProperty.Register(
                "By",
                typeofProp,
                typeofThis,
                new PropertyMetadata((CornerRadius?)null, propCallback),
                validateCallback);
        }

 public ReadOnlyPropertyMetadata(object defaultValue, 
                                 GetReadOnlyValueCallback getValueCallback,
                                 PropertyChangedCallback propertyChangedCallback) :
                                 base(defaultValue, propertyChangedCallback)
 {
     _getValueCallback = getValueCallback;
 }

 public PropertyMetadata(object defaultValue = null, PropertyChangedCallback propertyChangedCallback = null, CoerceValueCallback coerceValueCallback = null, bool inherits = false)
 {
     this.DefaultValue = defaultValue;
     this.PropertyChangedCallback = propertyChangedCallback;
     this.CoerceValueCallback = coerceValueCallback;
     this.Inherits = inherits;
 }

        /// <summary>
        /// Static ctor for QuaternionAnimation establishes
        /// dependency properties, using as much shared data as possible.
        /// </summary>
        static QuaternionAnimation()
        {
            Type typeofProp = typeof(Quaternion?);
            Type typeofThis = typeof(QuaternionAnimation);
            PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed);
            ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue);

            FromProperty = DependencyProperty.Register(
                "From",
                typeofProp,
                typeofThis,
                new PropertyMetadata((Quaternion?)null, propCallback),
                validateCallback);

            ToProperty = DependencyProperty.Register(
                "To",
                typeofProp,
                typeofThis,
                new PropertyMetadata((Quaternion?)null, propCallback),
                validateCallback);

            ByProperty = DependencyProperty.Register(
                "By",
                typeofProp,
                typeofThis,
                new PropertyMetadata((Quaternion?)null, propCallback),
                validateCallback);

            EasingFunctionProperty = DependencyProperty.Register(
                "EasingFunction",
                typeof(IEasingFunction),
                typeofThis);
        }

 public UIPropertyMetadata(
             object defaultValue,
             PropertyChangedCallback propertyChangedCallback,
             CoerceValueCallback coerceValueCallback)
             : base(defaultValue, propertyChangedCallback, coerceValueCallback)
 {
 }

 /// <summary>
 ///     UI metadata construction
 /// </summary>
 /// <param name="defaultValue">Default value of property</param>
 /// <param name="propertyChangedCallback">Called when the property has been changed</param>
 /// <param name="coerceValueCallback">Called on update of value</param>
 /// <param name="isAnimationProhibited">Should animation be prohibited?</param>
 public UIPropertyMetadata(object defaultValue,
                         PropertyChangedCallback propertyChangedCallback,
                         CoerceValueCallback coerceValueCallback,
                         bool isAnimationProhibited) :
     base(defaultValue, propertyChangedCallback, coerceValueCallback)
 {
     WriteFlag(MetadataFlags.UI_IsAnimationProhibitedID, isAnimationProhibited);
 }

 public static void RegisterForNotification(string property, FrameworkElement frameworkElement, PropertyChangedCallback OnCallBack)
 {
     Binding binding2 = new Binding(property);
     binding2.set_Source(frameworkElement);
     Binding binding = binding2;
     DependencyProperty property2 = DependencyProperty.RegisterAttached("ListenAttached" + property, typeof(object), typeof(UserControl), new PropertyMetadata(OnCallBack));
     frameworkElement.SetBinding(property2, binding);
 }

		public UIPropertyMetadata (object defaultValue,
					   PropertyChangedCallback propertyChangedCallback,
					   CoerceValueCallback coerceValueCallback,
					   bool isAnimationProhibited)
			: base (defaultValue, propertyChangedCallback, coerceValueCallback)
		{
			this.isAnimationProhibited = false;
		}

 /// <summary> 
 ///     Type meta construction
 /// </summary>
 /// <param name="defaultValue">Default value of property</param>
 /// <param name="propertyChangedCallback">Called when the property has been changed</param> 
 /// <param name="coerceValueCallback">Called on update of value</param>
 public PropertyMetadata(object defaultValue, 
                         PropertyChangedCallback propertyChangedCallback, 
                         CoerceValueCallback coerceValueCallback)
 { 
     DefaultValue = defaultValue;
     PropertyChangedCallback = propertyChangedCallback;
     CoerceValueCallback = coerceValueCallback;
 } 

        public PropertyMetadata(object defaultValue, PropertyChangedCallback propertyChangedCallback)
        {
            if (defaultValue == DependencyProperty.UnsetValue)
                throw new ArgumentException("Cannot initialize property metadata's default value to 'Unset'");

            DefaultValue = defaultValue;
            PropertyChangedCallback = propertyChangedCallback;
        }

 static StylizedTextBlock()
 {
     var metadata = TextProperty.GetMetadata(typeof(TextBlock));
     _originalTtextPropertyChangedCallback = metadata.PropertyChangedCallback;
     var originalCoerceValueCallback = metadata.CoerceValueCallback;
     TextProperty.OverrideMetadata(typeof(StylizedTextBlock), new FrameworkPropertyMetadata(string.Empty,
         FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender,
         OnTextChanged, originalCoerceValueCallback));
 }

 public FontPropertyMetadata(
     object defaultValue,
     PropertyChangedCallback changeCallback,
     DependencyProperty targetProperty
     )
     : base(defaultValue, changeCallback)
 {
     TargetProperty = targetProperty;
 }

 public FrameworkPropertyMetadata(object defaultValue = null, PropertyChangedCallback propertyChangedCallback = null, CoerceValueCallback coerceValueCallback = null, bool inherits = false,
     bool affectsMeasure = false, bool affectsArrange = false, bool bindsTwoWayByDefault = false, UpdateSourceTrigger defaultUpdateSourceTrigger = UpdateSourceTrigger.Default)
     : base(defaultValue, propertyChangedCallback, coerceValueCallback, inherits)
 {
     this.AffectsMeasure = affectsMeasure;
     this.AffectsArrange = affectsArrange;
     this.BindsTwoWayByDefault = bindsTwoWayByDefault;
     this.DefaultUpdateSourceTrigger = defaultUpdateSourceTrigger;
 }

        /// <summary>
        /// Register an attached dependency / bindable property
        /// </summary>
        /// <param name="name">The property name</param>
        /// <param name="propertyType">The property type</param>
        /// <param name="ownerType">The owner type</param>
        /// <param name="defaultValue">The default value</param>
        /// <param name="propertyChangedCallback">Callback to executed on property changed</param>
        /// <returns>The registred attached dependecy property</returns>
        public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, object defaultValue = null, PropertyChangedCallback propertyChangedCallback = null) {
#if XFORMS
            return DependencyProperty.CreateAttached(name, propertyType, ownerType, defaultValue, propertyChanged: (obj, oldValue, newValue) => {
                if (propertyChangedCallback != null)
                    propertyChangedCallback(obj, new DependencyPropertyChangedEventArgs(newValue, oldValue, null));
            });
#else
            return DependencyProperty.RegisterAttached(name, propertyType, ownerType, new PropertyMetadata(defaultValue, propertyChangedCallback));
#endif
        }

        static GameManagerProperties()
        {
            PropertyChangedCallback dockingManagerChanged =
                new PropertyChangedCallback(OnDockingManagerChanged);
            PropertyMetadata dockingManagerMetadata =
                new PropertyMetadata(null, dockingManagerChanged);

            DockingManagerProperty = DependencyProperty.RegisterAttached("DockingManager",
                typeof(DockingManager), typeof(GameManagerProperties), dockingManagerMetadata);
        }