static TestUserControl()
        {
            PropertyMetadata metaData;

            metaData = new PropertyMetadata(Colors.Red);
            ColorProperty = DependencyProperty.Register("Color", typeof(Color), typeof(TestUserControl),metaData);
        }

        static ColorPick()
        {
            PropertyMetadata metaData;

            metaData = new PropertyMetadata(Colors.Red);
            ColorProperty = DependencyProperty.Register("Color", typeof(Color), typeof(ColorPick),metaData);
        }

        internal DependencyPropertyChangedEventArgs(
            DependencyProperty  property, 
            PropertyMetadata    metadata,
            bool                isAValueChange, 
            EffectiveValueEntry oldEntry, 
            EffectiveValueEntry newEntry,
            OperationType       operationType) 
        {
            _property             = property;
            _metadata             = metadata;
            _oldEntry             = oldEntry; 
            _newEntry             = newEntry;
 
            _flags = 0; 
            _operationType        = operationType;
            IsAValueChange        = isAValueChange; 

            // This is when a mutable default is promoted to a local value. On this operation mutable default
            // value acquires a freezable context. However this value promotion operation is triggered
            // whenever there has been a sub property change to the mutable default. Eg. Adding a TextEffect 
            // to a TextEffectCollection instance which is the mutable default. Since we missed the sub property
            // change due to this add, we flip the IsASubPropertyChange bit on the following change caused by 
            // the value promotion to coalesce these operations. 
            IsASubPropertyChange = (operationType == OperationType.ChangeMutableDefaultValue);
        } 

        static DiagramLabel()
        {
            var fontFamilyMd = new PropertyMetadata(new FontFamily("Arial"), OnFontFamilyChanged);
            FontFamilyProperty = DependencyProperty.Register("FontFamily", typeof (FontFamily), typeof (DiagramLabel), fontFamilyMd);

            var fontWeightMd = new PropertyMetadata(FontWeights.Normal, OnFontWeightChanged);
            FontWeightProperty = DependencyProperty.Register("FontWeight", typeof (FontWeight), typeof (DiagramLabel), fontWeightMd);

            const double defaultSize = 11;
            var fontSizeMd = new PropertyMetadata(defaultSize, OnFontSizeChanged);
            FontSizeProperty = DependencyProperty.Register("FontSize", typeof (double), typeof (DiagramLabel), fontSizeMd);

            var fontStyleMd = new PropertyMetadata(FontStyles.Normal, OnFontStyleChanged);
            FontStyleProperty = DependencyProperty.Register("FontStyle", typeof (FontStyle), typeof (DiagramLabel), fontStyleMd);

            var fontStretchMd = new PropertyMetadata(FontStretches.Normal, OnFontStretchChanged);
            FontStretchProperty = DependencyProperty.Register("FontStretch", typeof (FontStretch), typeof (DiagramLabel),
                                                              fontStretchMd);

            var foregroundMd = new PropertyMetadata(new SolidColorBrush(Colors.Black), OnForegroundChanged);
            ForegroundProperty = DependencyProperty.Register("Foreground", typeof (Brush), typeof (DiagramLabel), foregroundMd);

            var relativePosMd = new PropertyMetadata(new Point(0, 0), OnRelativePositionChanged);
            RelativePositionProperty = DependencyProperty.Register("RelativePosition", typeof (Point), typeof (DiagramLabel), relativePosMd);

            var textMd = new PropertyMetadata("", OnTextChanged);
            TextProperty = DependencyProperty.Register("Text", typeof (String), typeof (DiagramLabel), textMd);
        }

		public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata)
		{
			if (typeMetadata == null) typeMetadata = new PropertyMetadata ();
			OverrideMetadata (ownerType, typeMetadata);

			// MS seems to always return the same DependencyProperty
			return this;
		}

        private static PropertyMetadata GetCurrentPageIndexPropetyMetadata()
        {
            PropertyMetadata pm = new PropertyMetadata();
            pm.DefaultValue = 1;
            pm.PropertyChangedCallback = new PropertyChangedCallback(CurrentPageIndexPropertyChanged);

            return pm;
        }

        /// <summary>
        ///     Override the metadata of a property that is already secured with
        /// this key.
        /// </summary>
        public void OverrideMetadata( Type forType, PropertyMetadata typeMetadata )
        {
            if( _dp == null )
            {
                throw new InvalidOperationException();
            }

            _dp.OverrideMetadata( forType, typeMetadata, this );
        }

        static EyeCandy()
        {

            //register attached dependency property
            var metadata = new PropertyMetadata((ImageSource)null);
            ImageProperty = DependencyProperty.RegisterAttached("Image",
                                                                typeof(ImageSource),
                                                                typeof(EyeCandy), metadata);
        }

    private DependencyProperty(DependencyProperty property, PropertyMetadata defaultMetadata)
    {
      _defaultMetadata = defaultMetadata;
      _name = property._name;
      _ownerType = property._ownerType;
      _propertyType = property._propertyType;
      _validateValueCallback = property._validateValueCallback;

      _properties[_name + _ownerType] = this;
    }

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

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

		private DependencyProperty (bool isAttached, string name, Type propertyType, Type ownerType,
					    PropertyMetadata defaultMetadata,
					    ValidateValueCallback validateValueCallback)
		{
			IsAttached = isAttached;
			DefaultMetadata = (defaultMetadata == null ? new PropertyMetadata() : defaultMetadata);
			Name = name;
			OwnerType = ownerType;
			PropertyType = propertyType;
			ValidateValueCallback = validateValueCallback;
		}

        static DiagramNode()
        {
            var boundsMd = new PropertyMetadata(new Rect(0, 0, 0, 0), OnBoundsChanged);
            BoundsProperty = DependencyProperty.Register("Bounds", typeof(Rect), typeof(DiagramNode), boundsMd);

            var radiusXMd = new PropertyMetadata(0.0, OnRadiusXChanged);
            RadiusXProperty = DependencyProperty.Register("RadiusX", typeof(double), typeof(DiagramNode), radiusXMd);

            var radiusYMd = new PropertyMetadata(0.0, OnRadiusYChanged);
            RadiusYProperty = DependencyProperty.Register("RadiusY", typeof(double), typeof(DiagramNode), radiusYMd);
        }

        static DiagramEdge()
        {
            var sourcePointMd = new PropertyMetadata(new Point(0, 0), OnSourcePointChanged);
            SourcePointProperty = DependencyProperty.Register("SourcePoint", typeof (Point), typeof (DiagramEdge), sourcePointMd);

            var destinationPointMd = new PropertyMetadata(new Point(0, 0), OnDestinationPointChanged);
            DestinationPointProperty = DependencyProperty.Register("DestinationPoint", typeof (Point), typeof (DiagramEdge), destinationPointMd);

            var anchoringModeMd = new PropertyMetadata(EdgeAnchoringMode.PointToPoint, OnAnchoringModeChanged);
            AnchoringModeProperty = DependencyProperty.Register("AnchoringMode", typeof (EdgeAnchoringMode), typeof (DiagramEdge), anchoringModeMd);
        }

		DependencyProperty ( 
			string propertyName, 
			Type propertyType, 
			Type ownerType, 
			PropertyMetadata metadata ) {

			this.Name = propertyName;
			this.PropertyType = propertyType;
			this.OwnerType = ownerType;
			this.DefaultMetadata = metadata;
		}

        public FastComboBox()
        {
            var propertyMetadata = new PropertyMetadata(OnItemsSource2Changed);

            ItemsSource2Property = DependencyProperty.Register(
                "ItemsSource2"
                , typeof(IEnumerable)
                , typeof(FastComboBox)
                , propertyMetadata);

            DefaultStyleKey = typeof(FastComboBox);
        }

        public void Should_Return_Same_DependencyProperty()
        {
            PropertyMetadata metadata1 = new PropertyMetadata("foo");
            DependencyProperty dp1 = DependencyProperty.Register(
                "Should_Return_Same_DependencyProperty",
                typeof(string),
                typeof(TestClass1),
                metadata1);

            DependencyProperty dp2 = dp1.AddOwner(typeof(TestClass2));

            Assert.AreSame(dp1, dp2);
        }

        public void Should_Not_Change_OwnerType()
        {
            PropertyMetadata metadata1 = new PropertyMetadata("foo");
            DependencyProperty dp = DependencyProperty.Register(
                "Should_Not_Change_OwnerType",
                typeof(string),
                typeof(TestClass1),
                metadata1);

            dp.AddOwner(typeof(TestClass2));

            Assert.AreEqual(typeof(TestClass1), dp.OwnerType);
        }

        static Diagram()
        {
            var xViewOffsetMd = new PropertyMetadata(0.0, OnXViewOffsetChanged);
            XViewOffsetProperty = DependencyProperty.Register("XViewOffset", typeof(double), typeof(Diagram), xViewOffsetMd);

            var yViewOffsetMd = new PropertyMetadata(0.0, OnYViewOffsetChanged);
            YViewOffsetProperty = DependencyProperty.Register("YViewOffset", typeof(double), typeof(Diagram), yViewOffsetMd);

            var scaleMd = new PropertyMetadata(1.0, OnZoomChanged);
            ScaleProperty = DependencyProperty.Register("Scale", typeof(double), typeof(Diagram), scaleMd);

            var scaleFactorMd = new PropertyMetadata(1.1);
            ScaleFactorProperty = DependencyProperty.Register("ScaleFactor", typeof(double), typeof(Diagram), scaleFactorMd);
        }

        static DiagramItem()
        {
            var backgroundMd = new PropertyMetadata(new SolidColorBrush(Colors.Transparent), OnBackgroundChanged);
            BackgroundProperty = DependencyProperty.Register("Background", typeof(Brush), typeof(DiagramItem), backgroundMd);

            var borderPenMd = new PropertyMetadata(new Pen(Brushes.Black, 1), OnBorderPenChanged);
            BorderPenProperty = DependencyProperty.Register("BorderPen", typeof(Pen), typeof(DiagramItem), borderPenMd);

            var dataMd = new PropertyMetadata(null, OnDataChanged);
            DataProperty = DependencyProperty.Register("Data", typeof(object), typeof(DiagramItem), dataMd);

            var userDataMd = new PropertyMetadata(null, OnUserDataChanged);
            UserDataProperty = DependencyProperty.Register("UserData", typeof(object), typeof(DiagramItem), userDataMd);
        }

 static MainWindow()
 {
     var metadata = new PropertyMetadata(new ObservableCollection<long>
                                             {
                                                 3,
                                                 2,
                                                 17,
                                                 20,
                                                 63553547345645653,
                                                 34563456314523431,
                                                 989956756956978671,
                                                 989956756956978673,
                                             });
     NumbersProperty = DependencyProperty.Register("Numbers", typeof(ObservableCollection<long>), typeof(MainWindow), metadata);
 }