Some repairs

XAML conversion/Parsers/ObjectParser.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Xml.Linq;
+using System.Windows.Markup;
 
 namespace XamlConversion.Parsers
 {
     class ObjectParser : XamlParser
     {
         public ObjectParser(XamlConvertor.State state)
             : base(state)
-        {}
+        { }
 
         public string VariableName { get; protected set; }
 
@@ -24,9 +25,16 @@ protected override void ParseAttribute(XAttribute attribute)
         {
             if (attribute.IsNamespaceDeclaration)
                 return;
+            try
+            {
+                var propertyName = attribute.Name.LocalName;
+                SetProperty(VariableName, Type, propertyName, attribute.Value);
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine(attribute.Name);
+            }
 
-            var propertyName = attribute.Name.LocalName;
-            SetProperty(VariableName, Type, propertyName, attribute.Value);
         }
 
         protected override void ParseElement(XElement element)
@@ -39,11 +47,23 @@ protected override void ParseElement(XElement element)
             }
             else
             {
-                throw new NotImplementedException();
+                var propertyParser = new PropertyParser(State, this);
+                object[] attributes = Type.GetCustomAttributes(typeof(ContentPropertyAttribute), true);
+
+                if (attributes.Length > 0)
+                {
+                    XElement e = new XElement(VariableName + "." +
+                        (attributes[0] as ContentPropertyAttribute).Name, element);
+                    propertyParser.Parse(e);
+                }
+                else
+                {
+                    throw new NotImplementedException();
+                }
             }
         }
 
         protected override void ParseEnd()
-        {}
+        { }
     }
-}
+}

XAML conversion/Parsers/ParserBase.cs

@@ -63,23 +63,54 @@ protected CodeExpression ConvertTo(string value, Type type)
             if (converter == null)
                 return valueExpression;
 
-            var conversion = new CodeCastExpression(
-                type.Name,
-                new CodeMethodInvokeExpression(
-                    new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("TypeDescriptor"), "GetConverter",
-                                                   new CodeTypeOfExpression(type.Name)), "ConvertFromInvariantString",
-                    new CodePrimitiveExpression(value)));
-
-            return conversion;
+            if (converter.CanConvertFrom(typeof(String)))
+            {
+                var conversion = new CodeCastExpression(
+                    type.Name,
+                    new CodeMethodInvokeExpression(
+                        new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("TypeDescriptor"), "GetConverter",
+                            new CodeTypeOfExpression(type.Name)), "ConvertFromInvariantString",
+                            new CodePrimitiveExpression(value)));
+
+                return conversion;
+            }
+            else
+            {
+                throw new NotImplementedException();
+            }
         }
 
         protected void SetProperty(string variableName, Type variableType, string propertyName, string value)
         {
-            var left = new CodePropertyReferenceExpression(
-                new CodeVariableReferenceExpression(variableName), propertyName);
-            var right = ConvertTo(value, GetPropertyType(propertyName, variableType));
-            var assignment = new CodeAssignStatement(left, right);
-            State.AddStatement(assignment);
+
+            if (value.StartsWith("{"))
+            {
+                throw new NotImplementedException();
+            }
+
+            // is it a Attached property?
+            if (propertyName.Contains("."))
+            {
+                var s = propertyName.Split('.');
+                string staticObjName = s[0];
+                CodeMethodInvokeExpression addExpression = new CodeMethodInvokeExpression(
+                    new CodeTypeReferenceExpression(GetTypeFromXName(s[0])),
+                    "Set" + s[1],
+                    new CodeExpression[] 
+                    { new CodeVariableReferenceExpression(variableName), 
+                        new CodePrimitiveExpression(value)});
+
+                State.AddStatement(new CodeExpressionStatement(addExpression));
+            }
+            else
+            {
+                var left = new CodePropertyReferenceExpression(
+                    new CodeVariableReferenceExpression(variableName), propertyName);
+                var right = ConvertTo(value, GetPropertyType(propertyName, variableType));
+                var assignment = new CodeAssignStatement(left, right);
+                State.AddStatement(assignment);
+            }
+
         }
     }
-}
+}

XAML conversion/Parsers/PropertyCollectionParser.cs

@@ -1,13 +1,15 @@
 using System.CodeDom;
 using System.Xml.Linq;
+using System.Collections;
+using System;
 
 namespace XamlConversion.Parsers
 {
     class PropertyCollectionParser : PropertyParser
     {
         public PropertyCollectionParser(XamlConvertor.State state, ObjectParser parent)
             : base(state, parent)
-        {}
+        { }
 
         protected override void ParseName(XName name)
         {
@@ -19,14 +21,48 @@ protected override void ParseElement(XElement element)
         {
             var objectParser = new ObjectParser(State);
             objectParser.Parse(element);
-            var addExpression =
-                new CodeMethodInvokeExpression(
+
+            CodeMethodInvokeExpression addExpression;
+            if (typeof(IDictionary).IsAssignableFrom(Type))
+            {
+                string stringKey = GetKeyAttribute(element);
+                CodeExpression key;
+                if (stringKey != "")
+                {
+                    key = new CodePrimitiveExpression(stringKey);
+                }
+                else
+                {
+                    key = new CodeVariableReferenceExpression(objectParser.VariableName);
+                }
+
+                addExpression = new CodeMethodInvokeExpression(
+                    new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(Parent.VariableName), Name),
+                    "Add", new CodeExpression[] { key, new CodeVariableReferenceExpression(objectParser.VariableName) });
+
+            }
+            else
+            {
+                addExpression = new CodeMethodInvokeExpression(
                     new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(Parent.VariableName), Name),
                     "Add", new CodeVariableReferenceExpression(objectParser.VariableName));
+            }
+
+
             State.AddStatement(new CodeExpressionStatement(addExpression));
         }
 
+        private string GetKeyAttribute(XElement element)
+        {
+            foreach (var a in element.Attributes())
+            {
+                if (a.Name.LocalName == "Key") return a.Value;
+            }
+
+            return "";
+        }
+
         protected override void ParseEnd()
-        {}
+        { }
     }
-}
+}