From 6bd5f85d4d924caccda85ce8b3d757d57b2d3f32 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 19 Oct 2015 11:05:44 +0200
Subject: [PATCH] Update Owner when AddOwnering properties.

---
 src/Perspex.Base/PerspexProperty.cs           | 56 +++++++++++++++++--
 src/Perspex.Base/PerspexProperty`1.cs         | 28 ++++++++--
 .../PerspexPropertyTests.cs                   | 18 ++++++
 3 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/src/Perspex.Base/PerspexProperty.cs b/src/Perspex.Base/PerspexProperty.cs
index 62a3d5cfe2..2dd679ce8d 100644
--- a/src/Perspex.Base/PerspexProperty.cs
+++ b/src/Perspex.Base/PerspexProperty.cs
@@ -29,7 +29,12 @@ namespace Perspex
         private static int s_nextId = 1;
 
         /// <summary>
-        /// The default values for the property, by type.
+        /// The default value provided when the property was first registered.
+        /// </summary>
+        private readonly object _defaultValue;
+
+        /// <summary>
+        /// The overridden default values for the property, by type.
         /// </summary>
         private readonly Dictionary<Type, object> _defaultValues = new Dictionary<Type, object>();
 
@@ -93,7 +98,7 @@ namespace Perspex
             Name = name;
             PropertyType = valueType;
             OwnerType = ownerType;
-            _defaultValues.Add(ownerType, defaultValue);
+            _defaultValue = defaultValue;
             Inherits = inherits;
             DefaultBindingMode = defaultBindingMode;
             IsAttached = isAttached;
@@ -144,14 +149,57 @@ namespace Perspex
         /// Initializes a new instance of the <see cref="PerspexProperty"/> class.
         /// </summary>
         /// <param name="source">The direct property to copy.</param>
+        /// <param name="ownerType">The new owner type.</param>
+        protected PerspexProperty(PerspexProperty source, Type ownerType)
+        {
+            Contract.Requires<ArgumentNullException>(source != null);
+            Contract.Requires<ArgumentNullException>(ownerType != null);
+
+            if (source.IsDirect)
+            {
+                throw new InvalidOperationException(
+                    "This method cannot be called on direct PerspexProperties.");
+            }
+
+            //Name = name;
+            //PropertyType = valueType;
+            //OwnerType = ownerType;
+            //_defaultValues.Add(ownerType, defaultValue);
+            //Inherits = inherits;
+            //DefaultBindingMode = defaultBindingMode;
+            //IsAttached = isAttached;
+            //Notifying = notifying;
+            //_id = s_nextId++;
+
+
+            Name = source.Name;
+            PropertyType = source.PropertyType;
+            OwnerType = ownerType;
+            _defaultValue = source._defaultValue;
+            _defaultValues = source._defaultValues;
+            Inherits = source.Inherits;
+            DefaultBindingMode = source.DefaultBindingMode;
+            IsAttached = false;
+            Notifying = Notifying;
+            _validation = source._validation;
+            _id = source._id;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PerspexProperty"/> class.
+        /// </summary>
+        /// <param name="source">The direct property to copy.</param>
+        /// <param name="ownerType">The new owner type.</param>
         /// <param name="getter">A new getter.</param>
         /// <param name="setter">A new setter.</param>
         protected PerspexProperty(
             PerspexProperty source,
+            Type ownerType,
             Func<PerspexObject, object> getter,
             Action<PerspexObject, object> setter)
         {
             Contract.Requires<ArgumentNullException>(source != null);
+            Contract.Requires<ArgumentNullException>(ownerType != null);
             Contract.Requires<ArgumentNullException>(getter != null);
 
             if (!source.IsDirect)
@@ -162,7 +210,7 @@ namespace Perspex
 
             Name = source.Name;
             PropertyType = source.PropertyType;
-            OwnerType = source.OwnerType;
+            OwnerType = ownerType;
             Getter = getter;
             Setter = setter;
             IsDirect = true;
@@ -530,7 +578,7 @@ namespace Perspex
                 type = type.GetTypeInfo().BaseType;
             }
 
-            return _defaultValues[OwnerType];
+            return _defaultValue;
         }
 
         /// <summary>
diff --git a/src/Perspex.Base/PerspexProperty`1.cs b/src/Perspex.Base/PerspexProperty`1.cs
index 9a39b95c0c..6d97833f0a 100644
--- a/src/Perspex.Base/PerspexProperty`1.cs
+++ b/src/Perspex.Base/PerspexProperty`1.cs
@@ -66,17 +66,29 @@ namespace Perspex
             Setter = setter;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PerspexProperty"/> class.
+        /// </summary>
+        /// <param name="source">The property to copy.</param>
+        /// <param name="ownerType">The new owner type.</param>
+        private PerspexProperty(PerspexProperty source, Type ownerType)
+            : base(source, ownerType)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="PerspexProperty"/> class.
         /// </summary>
         /// <param name="source">The direct property to copy.</param>
+        /// <param name="ownerType">The new owner type.</param>
         /// <param name="getter">A new getter.</param>
         /// <param name="setter">A new setter.</param>
         private PerspexProperty(
             PerspexProperty source,
+            Type ownerType,
             Func<PerspexObject, TValue> getter,
             Action<PerspexObject, TValue> setter)
-            : base(source, CastParamReturn(getter), CastParams(setter))
+            : base(source, ownerType, CastParamReturn(getter), CastParams(setter))
         {
             Getter = getter;
             Setter = setter;
@@ -105,8 +117,9 @@ namespace Perspex
                     "You must provide a new getter and setter when calling AddOwner on a direct PerspexProperty.");
             }
 
-            PerspexPropertyRegistry.Instance.Register(typeof(TOwner), this);
-            return this;
+            var result = new PerspexProperty<TValue>(this, typeof(TOwner));
+            PerspexPropertyRegistry.Instance.Register(typeof(TOwner), result);
+            return result;
         }
 
         /// <summary>
@@ -119,8 +132,15 @@ namespace Perspex
             Action<TOwner, TValue> setter = null)
                 where TOwner : PerspexObject
         {
+            if (!IsDirect)
+            {
+                throw new InvalidOperationException(
+                    "This overload of AddOwner is for direct PerspexProperties.");
+            }
+
             var result = new PerspexProperty<TValue>(
-                this, 
+                this,
+                typeof(TOwner),
                 CastReturn(getter), 
                 CastParam1(setter));
 
diff --git a/tests/Perspex.Base.UnitTests/PerspexPropertyTests.cs b/tests/Perspex.Base.UnitTests/PerspexPropertyTests.cs
index 6c90ac1039..c858152da5 100644
--- a/tests/Perspex.Base.UnitTests/PerspexPropertyTests.cs
+++ b/tests/Perspex.Base.UnitTests/PerspexPropertyTests.cs
@@ -161,6 +161,15 @@ namespace Perspex.Base.UnitTests
             Assert.True(p1 == p2);
         }
 
+        [Fact]
+        public void AddOwnered_Property_Should_Have_OwnerType_Set()
+        {
+            var p1 = new PerspexProperty<string>("p1", typeof(Class1));
+            var p2 = p1.AddOwner<Class3>();
+
+            Assert.Equal(typeof(Class3), p2.OwnerType);
+        }
+
         [Fact]
         public void AddOwnered_Direct_Property_Should_Equal_Original()
         {
@@ -172,6 +181,15 @@ namespace Perspex.Base.UnitTests
             Assert.True(p1 == p2);
         }
 
+        [Fact]
+        public void AddOwnered_Direct_Property_Should_Have_OwnerType_Set()
+        {
+            var p1 = new PerspexProperty<string>("d1", typeof(Class1), o => null, (o, v) => { });
+            var p2 = p1.AddOwner<Class3>(o => null, (o, v) => { });
+
+            Assert.Equal(typeof(Class3), p2.OwnerType);
+        }
+
         [Fact]
         public void AddOwner_With_Getter_And_Setter_On_Standard_Property_Should_Throw()
         {