2005-08-27 Iain McCoy <iain@mccoy.id.au>

        * Mono.Windows.Serialization/XamlParser.cs: added support for objects
        as values of dependency properties
        * Mono.Windows.Serialization/ParserToCode.cs: added support for code
        generation for objects as values of dependency properties
        * Test/XamlParser.cs: a test of same
        * System.Windows.Serialization/data-classes.txt: some minor
        refinements to enable the above
        * System.Windows.Serialization/Parser.cs: stubs for instantiating
        objects as values of dependency properties
        * demo/TestVocab/ConsoleValue.cs: some new features so that objects as
        values of dependency properties can be used in a vaguely sensible
        fashion
        * demo/test.xaml: added a demonstration of objects as values of
        dependency properties


svn path=/trunk/mcs/; revision=48965

6 files changed, 236 insertions, 65 deletions

diff --git a/mcs/class/PresentationFramework/ChangeLog b/mcs/class/PresentationFramework/ChangeLog
index e45700bbf06..630f4790b3d 100644
--- a/mcs/class/PresentationFramework/ChangeLog
+++ b/mcs/class/PresentationFramework/ChangeLog
@@ -1,3 +1,15 @@
+2005-08-27  Iain McCoy  <iain@mccoy.id.au>
+
+	* Mono.Windows.Serialization/XamlParser.cs: added support for objects
+	as values of dependency properties
+	* Mono.Windows.Serialization/ParserToCode.cs: added support for code
+	generation for objects as values of dependency properties
+	* Test/XamlParser.cs: a test of same
+	* System.Windows.Serialization/data-classes.txt: some minor
+	refinements to enable the above
+	* System.Windows.Serialization/Parser.cs: stubs for instantiating
+	objects as values of dependency properties
+
 2005-08-26  Iain McCoy  <iain@mccoy.id.au>
 
 	* System.Windows.Serialization/data-classes-builder.pl: tighten up
diff --git a/mcs/class/PresentationFramework/Mono.Windows.Serialization/ParserToCode.cs b/mcs/class/PresentationFramework/Mono.Windows.Serialization/ParserToCode.cs
index 409b805bf47..146f5950eff 100644
--- a/mcs/class/PresentationFramework/Mono.Windows.Serialization/ParserToCode.cs
+++ b/mcs/class/PresentationFramework/Mono.Windows.Serialization/ParserToCode.cs
@@ -72,6 +72,7 @@ namespace Mono.Windows.Serialization {
 		
 		private ParserToCode(XmlTextReader reader, ICodeGenerator generator, bool isPartial)
 		{
+			int justClosed = 0;
 			init(generator, isPartial);
 			XamlParser p = new XamlParser(reader);
 			XamlNode n;
@@ -89,6 +90,10 @@ namespace Mono.Windows.Serialization {
 				} else if (n is XamlElementStartNode && ((XamlElementStartNode)n).propertyObject) {
 					Debug.WriteLine("ParserToCode: element begins as property value");
 					CreatePropertyObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
+				} else if (n is XamlElementStartNode && ((XamlElementStartNode)n).depPropertyObject) {
+					Debug.WriteLine("ParserToCode: element begins as dependency property value");
+					CreateDependencyPropertyObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
+
 				} else if (n is XamlElementStartNode) {
 					Debug.WriteLine("ParserToCode: element begins");
 					CreateObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
@@ -127,16 +132,29 @@ namespace Mono.Windows.Serialization {
 					EndDependencyProperty();
 				} else if (n is XamlPropertyComplexEndNode) {
 					Debug.WriteLine("ParserToCode: end complex property");
-					Debug.WriteLine("ParserToCode: final type is " + ((XamlPropertyComplexEndNode)n).finalType);
-					EndPropertyObject(((XamlPropertyComplexEndNode)n).finalType);
-					EndProperty();
+					if (justClosed == 2) {
+						EndProperty();
+					} else if (justClosed == 1) {
+						EndDependencyProperty();
+					} else {
+						throw new NotImplementedException("justClosed of " + justClosed);
+					}
+					justClosed = 0;
 				} else if (n is XamlLiteralContentNode) {
 					Debug.WriteLine("ParserToCode: literal content");
 					CreateCode(((XamlLiteralContentNode)n).Content);
 				} else if (n is XamlElementEndNode) {
 					Debug.WriteLine("ParserToCode: end element");
-					if (!((XamlElementEndNode)n).propertyObject)
+					Type ft = ((XamlElementEndNode)n).finalType;
+					if (((XamlElementEndNode)n).propertyObject) {
+						EndPropertyObject(ft);
+						justClosed = 2;
+					} else if (((XamlElementEndNode)n).depPropertyObject) {
+						EndDependencyPropertyObject(ft);
+						justClosed = 1;
+					} else {
 						EndObject();
+					}
 				} else if (n is XamlDocumentEndNode) {
 					Debug.WriteLine("ParserToCode: end document");
 					Finish();
@@ -363,6 +381,11 @@ namespace Mono.Windows.Serialization {
 			constructor.Statements.Add(assignment);
 		}
 
+		public void CreateDependencyPropertyObject(Type type, string varName)
+		{
+			CreatePropertyObject(type, varName);
+		}
+
 		public void CreatePropertyObject(Type type, string varName)
 		{
 			debug();
@@ -404,6 +427,10 @@ namespace Mono.Windows.Serialization {
 		
 		}
 
+		public void EndDependencyPropertyObject(Type destType)
+		{
+			EndPropertyObject(destType);
+		}
 		public void EndPropertyObject(Type destType)
 		{
 			debug();
diff --git a/mcs/class/PresentationFramework/Mono.Windows.Serialization/XamlParser.cs b/mcs/class/PresentationFramework/Mono.Windows.Serialization/XamlParser.cs
index b7702f792d5..eda245a8bdd 100644
--- a/mcs/class/PresentationFramework/Mono.Windows.Serialization/XamlParser.cs
+++ b/mcs/class/PresentationFramework/Mono.Windows.Serialization/XamlParser.cs
@@ -47,6 +47,7 @@ namespace Mono.Windows.Serialization {
 			Property, 
 			PropertyObject,
 			DependencyProperty,
+			DependencyPropertyObject,
 	       		Code }
 
 		private class ParserState {
@@ -56,9 +57,12 @@ namespace Mono.Windows.Serialization {
 	
 		private bool begun = false;
 
-		private ParserState currentState() {
+		private ParserState currentState(int x) {
 			if (oldStates.Count == 0) return null;
-			return (ParserState)oldStates[oldStates.Count - 1];
+			return (ParserState)oldStates[oldStates.Count - 1 - x];
+		}
+		private ParserState currentState() {
+			return currentState(0);
 		}
 		private ArrayList oldStates = new ArrayList();
 
@@ -184,7 +188,8 @@ namespace Mono.Windows.Serialization {
 			//  name before the dot.
 			int dotPosition = reader.LocalName.IndexOf('.');
 			if (dotPosition < 0 ||
-					currentState().type == CurrentType.Property) {
+					currentState().type == CurrentType.Property ||
+					currentState().type == CurrentType.DependencyProperty) {
 				parseObjectElement();
 				return;
 			}
@@ -225,6 +230,7 @@ namespace Mono.Windows.Serialization {
 			switch (currentState().type) {
 			case CurrentType.Object:
 			case CurrentType.PropertyObject:
+			case CurrentType.DependencyPropertyObject:
 				abortIfNotAddChild("text");
 				((XamlTextNode)topNode()).setmode(XamlParseMode.Object);
 //				writer.CreateObjectText(reader.Value);
@@ -361,13 +367,17 @@ namespace Mono.Windows.Serialization {
 				name = reader.GetAttribute("Name", reader.NamespaceURI);
 
 			Debug.WriteLine("XamlParser: parent is " + parent);
-			if (currentState().type == CurrentType.Object) {
+			if (currentState().type == CurrentType.Object ||
+					currentState().type == CurrentType.PropertyObject ||
+					currentState().type == CurrentType.DependencyPropertyObject) {
 				abortIfNotAddChild("object");
 				addChild(parent, name);
 			} else if (currentState().type == CurrentType.Property) {
 				addPropertyChild(parent, name);
+			} else if (currentState().type == CurrentType.DependencyProperty) {
+				addDependencyPropertyChild(parent, name);
 			} else {
-				throw new NotImplementedException();
+				throw new NotImplementedException(currentState().type.ToString());
 			}
 		}
 		void processObjectAttributes()
@@ -400,13 +410,27 @@ namespace Mono.Windows.Serialization {
 					reader.LinePosition,
 					getDepth()));
 				((XamlElementEndNode)topNode()).setpropertyObject(true);
+				((XamlElementEndNode)topNode()).setfinalType(((PropertyInfo)currentState(1).obj).PropertyType);
 				nodeQueue.Add(new XamlPropertyComplexEndNode(
 					reader.LineNumber,
 					reader.LinePosition,
 					getDepth()));
-				((XamlPropertyComplexEndNode)topNode()).setfinalType((Type)currentState().obj);
 //				ParserState state = (ParserState)oldStates[oldStates.Count - 1];
 //				writer.EndPropertyObject(((PropertyInfo)state.obj).PropertyType);
+			} else if (currentState().type == CurrentType.DependencyPropertyObject) {
+				nodeQueue.Add(new XamlElementEndNode(
+					reader.LineNumber,
+					reader.LinePosition,
+					getDepth()));
+				((XamlElementEndNode)topNode()).setdepPropertyObject(true);
+				((XamlElementEndNode)topNode()).setfinalType(((DependencyProperty)currentState(1).obj).PropertyType);
+				nodeQueue.Add(new XamlPropertyComplexEndNode(
+					reader.LineNumber,
+					reader.LinePosition,
+					getDepth()));
+//				ParserState state = (ParserState)oldStates[oldStates.Count - 1];
+//				writer.EndPropertyObject(((PropertyInfo)state.obj).PropertyType);
+
 			}
 			tempStateCount --;
 			pop();
@@ -465,6 +489,25 @@ namespace Mono.Windows.Serialization {
 			push(CurrentType.PropertyObject, type);
 		}
 
+		void addDependencyPropertyChild(Type type, string objectName)
+		{
+//			writer.CreatePropertyObject(type, objectName);
+			nodeQueue.Add(new XamlElementStartNode(
+					reader.LineNumber,
+					reader.LinePosition,
+					getDepth(),
+					type.Assembly.FullName,
+					type.AssemblyQualifiedName,
+					type,
+					null));
+			((XamlElementStartNode)topNode()).setname(objectName);
+			((XamlElementStartNode)topNode()).setdepPropertyObject(true);
+
+
+			push(CurrentType.DependencyPropertyObject, type);
+		}
+
+
 
 		
 		void parseLocalPropertyAttribute()
@@ -544,7 +587,8 @@ namespace Mono.Windows.Serialization {
 			Type typeAttachedTo = null;
 			foreach (ParserState state in oldStates) {
 				if ((state.type == CurrentType.Object || 
-						state.type == CurrentType.PropertyObject) &&
+						state.type == CurrentType.PropertyObject ||
+						state.type == CurrentType.DependencyPropertyObject) &&
 						((Type)state.obj).Name == attachedTo) {
 					typeAttachedTo = (Type)state.obj;
 					break;
@@ -573,7 +617,7 @@ namespace Mono.Windows.Serialization {
 			ensureDependencyObject(currentType);
 			Type typeAttachedTo = findTypeToAttachTo(attachedTo, propertyName);
 			DependencyProperty dp = getDependencyProperty(typeAttachedTo, propertyName);
-			
+		
 			nodeQueue.Add(new XamlPropertyNode(
 					reader.LineNumber,
 					reader.LinePosition,
@@ -622,25 +666,29 @@ namespace Mono.Windows.Serialization {
 						reader.LinePosition,
 						getDepth()));
 				((XamlElementEndNode)topNode()).setpropertyObject(true);
+				((XamlElementEndNode)topNode()).setfinalType(((PropertyInfo)currentState(1).obj).PropertyType);
 				nodeQueue.Add(new XamlPropertyComplexEndNode(
 						reader.LineNumber,
 						reader.LinePosition,
 						getDepth()));
-				Debug.WriteLine("XamlParser: XXXXXXXX" + currentState().obj);
-				Debug.WriteLine("XamlParser: XXXXXXXX" + (currentState().obj is Type));
-				((XamlPropertyComplexEndNode)topNode()).setfinalType((Type)currentState().obj);
-				Debug.WriteLine("XamlParser: XXXXXXXX" + ((XamlPropertyComplexEndNode)topNode()).finalType);
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 1]).obj.GetType());
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 1]).type);
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 2]).obj.GetType());
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 2]).type);
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 3]).obj.GetType());
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 3]).type);
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 4]).obj.GetType());
-				Debug.WriteLine("TTTTTTTTT " + ((ParserState)oldStates[oldStates.Count - 4]).type);
 //				writer.EndPropertyObject((Type)currentState().obj);
 //				return;
 				break;
+			case CurrentType.DependencyPropertyObject:
+				nodeQueue.Add(new XamlElementEndNode(
+						reader.LineNumber,
+						reader.LinePosition,
+						getDepth()));
+				((XamlElementEndNode)topNode()).setdepPropertyObject(true);
+				((XamlElementEndNode)topNode()).setfinalType(((DependencyProperty)currentState(1).obj).PropertyType);
+				nodeQueue.Add(new XamlPropertyComplexEndNode(
+						reader.LineNumber,
+						reader.LinePosition,
+						getDepth()));
+//				writer.EndPropertyObject((Type)currentState().obj);
+//				return;
+				break;
+
 			// these next two happen automatically in the new model
 			case CurrentType.Property:
 //				writer.EndProperty();
diff --git a/mcs/class/PresentationFramework/System.Windows.Serialization/Parser.cs b/mcs/class/PresentationFramework/System.Windows.Serialization/Parser.cs
index 3b50d5c8dd2..6b5e7543059 100644
--- a/mcs/class/PresentationFramework/System.Windows.Serialization/Parser.cs
+++ b/mcs/class/PresentationFramework/System.Windows.Serialization/Parser.cs
@@ -61,64 +61,78 @@ namespace System.Windows.Serialization {
 				n = p.GetNextNode();
 				if (n == null)
 					break;
-				Debug.WriteLine("ObjectWriter: INCOMING " + n.GetType());
+				Debug.WriteLine("ParserToCode: INCOMING " + n.GetType());
 				if (n is XamlDocumentStartNode) {
-					Debug.WriteLine("ObjectWriter: document begins");
+					Debug.WriteLine("ParserToCode: document begins");
 					// do nothing
 				} else if (n is XamlElementStartNode && n.Depth == 0) {
-					Debug.WriteLine("ObjectWriter: element begins as top-level");
+					Debug.WriteLine("ParserToCode: element begins as top-level");
 					CreateTopLevel(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
-				} else if (n is XamlElementStartNode && peek() is PropertyInfo) {
-					Debug.WriteLine("ObjectWriter: element begins as property value");
+				} else if (n is XamlElementStartNode && ((XamlElementStartNode)n).propertyObject) {
+					Debug.WriteLine("ParserToCode: element begins as property value");
 					CreatePropertyObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
+				} else if (n is XamlElementStartNode && ((XamlElementStartNode)n).depPropertyObject) {
+					Debug.WriteLine("ParserToCode: element begins as dependency property value");
+					CreateDependencyPropertyObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
+
 				} else if (n is XamlElementStartNode) {
-					Debug.WriteLine("ObjectWriter: element begins");
+					Debug.WriteLine("ParserToCode: element begins");
 					CreateObject(((XamlElementStartNode)n).ElementType, ((XamlElementStartNode)n).name);
 				} else if (n is XamlPropertyNode && ((XamlPropertyNode)n).PropInfo != null) {
-					Debug.WriteLine("ObjectWriter: normal property begins");
+					Debug.WriteLine("ParserToCode: normal property begins");
 					CreateProperty(((XamlPropertyNode)n).PropInfo);
 				} else if (n is XamlPropertyNode && ((XamlPropertyNode)n).DP != null) {
-					Debug.WriteLine("ObjectWriter: dependency property begins");
+					Debug.WriteLine("ParserToCode: dependency property begins");
 					DependencyProperty dp = ((XamlPropertyNode)n).DP;
 					Type typeAttachedTo = dp.OwnerType;
 					string propertyName = ((XamlPropertyNode)n).PropertyName;
 					
 					CreateDependencyProperty(typeAttachedTo, propertyName, dp.PropertyType);
+				} else if (n is XamlClrEventNode && !(((XamlClrEventNode)n).EventMember is EventInfo)) {
+					Debug.WriteLine("ParserToCode: delegate property");
+					CreatePropertyDelegate(((XamlClrEventNode)n).Value, ((PropertyInfo)((XamlClrEventNode)n).EventMember).PropertyType);
+					EndProperty();
+
+
 				} else if (n is XamlClrEventNode) {
-					Debug.WriteLine("ObjectWriter: event");
+					Debug.WriteLine("ParserToCode: event");
 					CreateEvent((EventInfo)((XamlClrEventNode)n).EventMember);
 					CreateEventDelegate(((XamlClrEventNode)n).Value, ((EventInfo)((XamlClrEventNode)n).EventMember).EventHandlerType);
 					EndEvent();
 
 				} else if (n is XamlTextNode && ((XamlTextNode)n).mode == XamlParseMode.Object){
-					Debug.WriteLine("ObjectWriter: text for object");
+					Debug.WriteLine("ParserToCode: text for object");
 					CreateObjectText(((XamlTextNode)n).TextContent);
 				} else if (n is XamlTextNode && ((XamlTextNode)n).mode == XamlParseMode.Property){
-					Debug.WriteLine("ObjectWriter: text for property");
-					Debug.WriteLine("THINGTYPE = " + peek().GetType());
-					CreatePropertyText(((XamlTextNode)n).TextContent, ((PropertyInfo)peek()).PropertyType);
+					Debug.WriteLine("ParserToCode: text for property");
+					CreatePropertyText(((XamlTextNode)n).TextContent, ((XamlTextNode)n).finalType);
 					EndProperty();
 				} else if (n is XamlTextNode && ((XamlTextNode)n).mode == XamlParseMode.DependencyProperty){
-					Debug.WriteLine("ObjectWriter: text for dependency property");
-					string propertyName = (string)peek();
-					Type attachedTo = (Type)peek(1);
-					CreateDependencyPropertyText(((XamlTextNode)n).TextContent, ((DependencyProperty)attachedTo.GetField(propertyName + "Property").GetValue(null)).PropertyType);
+					Debug.WriteLine("ParserToCode: text for dependency property");
+					CreateDependencyPropertyText(((XamlTextNode)n).TextContent, ((XamlTextNode)n).finalType);
 					EndDependencyProperty();
 				} else if (n is XamlPropertyComplexEndNode) {
-					Debug.WriteLine("ObjectWriter: end complex property");
-					Debug.WriteLine("ObjectWriter: final type is " + ((XamlPropertyComplexEndNode)n).finalType);
-					EndPropertyObject(((XamlPropertyComplexEndNode)n).finalType);
+					Debug.WriteLine("ParserToCode: end complex property");
 					EndProperty();
+				} else if (n is XamlLiteralContentNode) {
+					Debug.WriteLine("ParserToCode: literal content");
+					CreateCode(((XamlLiteralContentNode)n).Content);
 				} else if (n is XamlElementEndNode) {
-					Debug.WriteLine("ObjectWriter: end element");
-					if (!((XamlElementEndNode)n).propertyObject)
+					Debug.WriteLine("ParserToCode: end element");
+					Type ft = ((XamlElementEndNode)n).finalType;
+					if (((XamlElementEndNode)n).propertyObject)
+						EndPropertyObject(ft);
+					else if (((XamlElementEndNode)n).depPropertyObject)
+						EndDependencyPropertyObject(ft);
+					else
 						EndObject();
 				} else if (n is XamlDocumentEndNode) {
-					Debug.WriteLine("ObjectWriter: end document");
+					Debug.WriteLine("ParserToCode: end document");
 					Finish();
 				} else {
 					throw new Exception("Unknown node " + n.GetType());
 				}
+
 			}
 		}
 
@@ -216,6 +230,15 @@ namespace System.Windows.Serialization {
 			p.SetValue(o, value, null);
 		}
 
+		public void CreateDependencyPropertyObject(Type type, string name)
+		{
+			throw new NotImplementedException();
+		}
+		public void EndDependencyPropertyObject(Type finalType)
+		{
+			throw new NotImplementedException();
+		}
+
 		// top of stack is reference to an attached property
 		public void CreateDependencyPropertyText(string text, Type propertyType)
 		{
diff --git a/mcs/class/PresentationFramework/System.Windows.Serialization/data-classes.txt b/mcs/class/PresentationFramework/System.Windows.Serialization/data-classes.txt
index e9eaf80b239..35ddd610576 100644
--- a/mcs/class/PresentationFramework/System.Windows.Serialization/data-classes.txt
+++ b/mcs/class/PresentationFramework/System.Windows.Serialization/data-classes.txt
@@ -8,8 +8,8 @@ XamlDefAttributeNode(XamlAttributeNode): string name, +string value
 XamlDefTagNode(XamlAttributeNode): bool isEmptyElement, System.Xml.XmlReader xmlReader, string defTagName
 XamlDocumentEndNode
 XamlDocumentStartNode
-XamlElementStartNode: string assemblyName, string typeFullName, Type elementType, Type serializerType; string name, bool propertyObject
-XamlElementEndNode; bool propertyObject
+XamlElementStartNode: string assemblyName, string typeFullName, Type elementType, Type serializerType; string name, bool propertyObject, bool depPropertyObject
+XamlElementEndNode; bool propertyObject, bool depPropertyObject, Type finalType
 XamlEndAttributesNode: bool compact
 XamlKeyElementEndNode(XamlElementEndNode)
 XamlKeyElementStartNode(XamlElementStartNode)
@@ -19,7 +19,7 @@ XamlNode(object): XamlNodeType tokenType, int lineNumber, int linePosition, int
 XamlPIMappingNode: string xmlNamespace, string clrNamespace, string assemblyName
 XamlPropertyArrayEndNode
 XamlPropertyArrayStartNode(XamlPropertyComplexStartNode)
-XamlPropertyComplexEndNode; Type finalType
+XamlPropertyComplexEndNode
 XamlPropertyComplexStartNode: Object propertyMember, string assemblyName, string typeFullName, string propertyName; PropertyInfo PropInfo, DependencyProperty DP, MethodInfo AttachedPropertySetter
 XamlPropertyIDictionaryEndNode
 XamlPropertyIDictionaryStartNode(XamlPropertyComplexStartNode)
diff --git a/mcs/class/PresentationFramework/Test/XamlParser.cs b/mcs/class/PresentationFramework/Test/XamlParser.cs
index 32a1a4b6543..5e2afcf4e37 100644
--- a/mcs/class/PresentationFramework/Test/XamlParser.cs
+++ b/mcs/class/PresentationFramework/Test/XamlParser.cs
@@ -458,35 +458,35 @@ public class XamlParserTest {
 		object p = buildParser(new StringReader(MAPPING + s));
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlDocumentStartNode);
+		Assert.IsTrue(n is XamlDocumentStartNode, "A1");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlElementStartNode);
-		Assert.AreEqual(n.Depth, 0);
-		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleApp));
+		Assert.IsTrue(n is XamlElementStartNode, "B2");
+		Assert.AreEqual(n.Depth, 0, "B3");
+		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleApp), "B4");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlElementStartNode);
-		Assert.AreEqual(n.Depth, 1);
-		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleWriter));
+		Assert.IsTrue(n is XamlElementStartNode, "C1");
+		Assert.AreEqual(n.Depth, 1, "C2");
+		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleWriter), "C3");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlPropertyNode);
-		Assert.AreEqual(n.Depth, 2);
-		Assert.AreEqual(((XamlPropertyNode)n).DP, ConsoleApp.RepetitionsProperty);
+		Assert.IsTrue(n is XamlPropertyNode, "D1");
+		Assert.AreEqual(n.Depth, 2, "D2");
+		Assert.AreEqual(((XamlPropertyNode)n).DP, ConsoleApp.RepetitionsProperty, "D3");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlTextNode);
-		Assert.AreEqual(((XamlTextNode)n).TextContent, "3");
+		Assert.IsTrue(n is XamlTextNode, "E1");
+		Assert.AreEqual(((XamlTextNode)n).TextContent, "3", "E2");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlElementEndNode);
+		Assert.IsTrue(n is XamlElementEndNode, "F1");
 
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlElementEndNode);
+		Assert.IsTrue(n is XamlElementEndNode, "G1");
 		
 		n = getNextNode(p);
-		Assert.IsTrue(n is XamlDocumentEndNode);
+		Assert.IsTrue(n is XamlDocumentEndNode, "H1");
 
 	}
 
@@ -535,9 +535,11 @@ public class XamlParserTest {
 		Assert.IsTrue(n is XamlElementStartNode, "E1" + n.GetType());
 		Assert.AreEqual(3, n.Depth, "E2");
 		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleWriter), "E3");
+		assertPropState(n, true, false, "E4");
 
 		n = getNextNode(p);
 		Assert.IsTrue(n is XamlElementEndNode, "F1" + n.GetType());
+		assertPropState(n, true, false, "F2");
 
 		n = getNextNode(p);
 		Assert.IsTrue(n is XamlPropertyComplexEndNode, "G1");
@@ -554,6 +556,59 @@ public class XamlParserTest {
 	}
 
 	[Test]
+	public void TestObjectAsDependencyPropertyValue()
+	{
+		string s = "<ConsoleApp xmlns=\"console\" xmlns:x=\"http://schemas.microsoft.com/winfx/xaml/2005\">\n"+
+			"<ConsoleReader>\n" +
+			"<ConsoleApp.Repetitions><ConsoleWriter /></ConsoleApp.Repetitions>\n" +
+			"</ConsoleReader>\n" +
+			"</ConsoleApp>";
+		object p = buildParser(new StringReader(MAPPING + s));
+		XamlNode n;
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlDocumentStartNode, "A1");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementStartNode, "B1");
+		Assert.AreEqual(n.Depth, 0, "B2");
+		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleApp), "B3");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementStartNode, "C1");
+		Assert.AreEqual(1, n.Depth, "C2");
+		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleReader), "C3");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlPropertyNode, "D1");
+		Assert.AreEqual(2, n.Depth, "D2");
+		Assert.AreEqual(((XamlPropertyNode)n).DP, ConsoleApp.RepetitionsProperty, "D3");
+		
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementStartNode, "E1" + n.GetType());
+		Assert.AreEqual(3, n.Depth, "E2");
+		Assert.AreEqual(((XamlElementStartNode)n).ElementType, typeof(ConsoleWriter), "E3");
+		assertPropState(n, false, true, "E4");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementEndNode, "F1" + n.GetType());
+		assertPropState(n, false, true, "F2");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlPropertyComplexEndNode, "G1");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementEndNode, "H1");
+
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlElementEndNode, "I1");
+		
+		n = getNextNode(p);
+		Assert.IsTrue(n is XamlDocumentEndNode, "J1");
+
+	}
+
+
+	[Test]
 	[ExpectedException(typeof(Exception), "Cannot add object to instance of 'Xaml.TestVocab.Console.ConsoleValueString'.")]
 	public void TestRestrictionOfAddingObjectsToIAddChilds()
 	{
@@ -685,6 +740,12 @@ public class XamlParserTest {
 		makeGoBang(MAPPING + s);
 	}
 
+	void assertPropState(object n, bool prop, bool dprop, string label) {
+		bool dpropx = (bool)n.GetType().GetProperty("depPropertyObject", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(n, null);
+		bool propx = (bool)n.GetType().GetProperty("propertyObject", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(n, null);
+		Assert.IsTrue(dpropx == dprop && prop == propx, label + propx + dpropx);
+	}
+
 	XamlNode getNextNode(object p)
 	{
 		MethodInfo getter = p.GetType().GetMethod("GetNextNode");