private void CreateClass(CodeNamespace cns, CodeDomObjectNode objectNode, CodeMemberMethod initComponentMethod)
{
CodeTypeDeclaration rootType;
if (objectNode.XClassNode == null)
{
rootType = new CodeTypeDeclaration("My" + objectNode.Type.Name);
}
else
{
rootType = new CodeTypeDeclaration((string)((ValueNode)objectNode.XClassNode.ItemNodes[0]).Value);
}
// Keep a copy
MainCodeClassName = rootType.Name;
rootType.BaseTypes.Add(new CodeTypeReference(objectNode.Type.UnderlyingType));
rootType.IsPartial = true;
rootType.Attributes = MemberAttributes.Public;
cns.Types.Add(rootType);
rootType.Members.Add(initComponentMethod);
var cmf = new CodeMemberField(typeof(CultureInfo), CultureInfoString);
cmf.InitExpression = new CodeObjectCreateExpression(typeof(CultureInfo), new CodeSnippetExpression("\"en-us\""), new CodePrimitiveExpression(false));
rootType.Members.Add(cmf);
RootObject = rootType;
}
private void GenerateUsings(CodeNamespace cns, CodeDomObjectNode objectNode)
{
cns.Imports.Add(new CodeNamespaceImport("System"));
foreach (var namespaceName in NamespacesToUse.Keys)
{
cns.Imports.Add(new CodeNamespaceImport(namespaceName));
}
}
private CodeMemberMethod CreateInitializeMethod(CodeNamespace cns, CodeDomObjectNode objectNode)
{
TypeConverterDictionary = new Dictionary <Type, string>();
PublicObjects = new Dictionary <string, CodeDomObjectNode>();
CodeMemberMethod initComponentMethod = new CodeConstructor();
initComponentMethod.Attributes = MemberAttributes.Public;
var thisExpression = new CodeThisReferenceExpression();
AddMembers(initComponentMethod, thisExpression, objectNode);
return(initComponentMethod);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
CodeDomObjectNode objectNode = null;
if (writerStack.Count == 0)
{
objectNode = new CodeDomObjectNode();
writerStack.Push(objectNode);
}
else
{
objectNode = writerStack.Peek() as CodeDomObjectNode;
if (objectNode.Type != null)
{
objectNode = new CodeDomObjectNode();
writerStack.Push(objectNode);
}
}
objectNode.NamespaceNodes.Add(namespaceDeclaration.Prefix, namespaceDeclaration);
}
private void WriteObject(XamlType xamlType, bool isGetObject)
{
CodeDomObjectNode objectNode = null;
var propertyNode = writerStack.Peek() as MemberNode;
if (writerStack.Count > 0)
{
objectNode = writerStack.Peek() as CodeDomObjectNode;
if (!(objectNode != null && objectNode.NamespaceNodes.Count > 0))
{
objectNode = new CodeDomObjectNode();
writerStack.Push(objectNode);
}
else
{
//root node
objectNode.SchemaContext = SchemaContext;
}
}
else
{
//root node
objectNode = new CodeDomObjectNode();
objectNode.SchemaContext = SchemaContext;
writerStack.Push(objectNode);
}
objectNode.Type = xamlType;
objectNode.IsGetObject = isGetObject;
if (RootNode != null)
{
propertyNode.ItemNodes.Add(objectNode);
}
else
{
RootNode = objectNode;
}
}
private void DumpNodeTree(CodeDomObjectNode rootNode)
{
if (rootNode.Type != null)
{
Debug.WriteLine(rootNode.Type.Name);
}
var members = rootNode.MemberNodes;
foreach (var member in members)
{
Debug.WriteLine("Member={0}, Type={1}", member.Member.Name, member.Member.Type.Name);
foreach (var itemNode in member.ItemNodes)
{
var valueNode = itemNode as ValueNode;
if (valueNode != null)
{
var value = valueNode.Value as string;
Debug.WriteLine("Underlying Type={0}, Value={1}", member.Member.Type.UnderlyingType, value);
}
else
{
var objectNode = (CodeDomObjectNode)itemNode;
var xamlType = objectNode.Type;
if (xamlType == XamlLanguage.Static)
{
var valueNode2 = objectNode.XPosParamsNode.ItemNodes[0] as ValueNode;
var xamlTypeReference = valueNode2.Value as string;
string memberName = null;
string typeName = null;
var period = xamlTypeReference.IndexOf('.');
if (period > -1)
{
memberName = xamlTypeReference.Substring(period + 1);
typeName = xamlTypeReference.Substring(0, period);
}
var resolvedType = objectNode.Resolve(typeName);
//TODO: don't forget to make sure a using happens for the referencedXamlType
var typeName2 = resolvedType != null ? resolvedType.Name : xamlTypeReference;
Debug.WriteLine("TypeName={0}, MemberName={1}", typeName2, memberName);
}
else if (xamlType == XamlLanguage.Null)
{
Debug.WriteLine("NULL Expression");
}
else if (xamlType == XamlLanguage.Type)
{
var valueNode2 = objectNode.XPosParamsNode.ItemNodes[0] as ValueNode;
var xamlTypeReference = valueNode2.Value as string;
var resolvedType = objectNode.Resolve(xamlTypeReference);
//TODO: don't forget to make sure a using happens for the referencedXamlType
var typeName = resolvedType != null ? resolvedType.Name : xamlTypeReference;
Debug.WriteLine("Type Ref={0}", new object[] { typeName });
}
else if (xamlType == XamlLanguage.Reference)
{
}
else
{
if (objectNode.Type != null)
{
DumpNodeTree(objectNode);
}
else
{
DumpNodeTree(objectNode);
}
}
}
}
}
}
private void GenerateMemberAssignment(CodeMemberMethod initComponentMethod, MemberNode member, CodeExpression targetExpression, CodeExpression valueExpression,
CodeDomObjectNode targetObjectNode)
{
CodeStatement cs = null;
//if (member.Member.IsUnknown)
//{
// throw new Exception("Unknown member " + member.Member.Name);
//}
if (member.Member == XamlLanguage.Items)
{
var parentObjectNode = member.ParentObjectNode;
XamlType parentType = null;
if (parentObjectNode.IsGetObject)
{
parentType = parentObjectNode.ParentMemberNode.Member.Type;
}
else
{
parentType = parentObjectNode.Type;
}
if (parentType.IsDictionary)
{
if (!typeof(IDictionary).IsAssignableFrom(parentType.UnderlyingType))
{
throw new NotImplementedException("Support non-IDictionary adds");
}
CodeExpression keyExpression;
if (targetObjectNode.XKeyNode != null)
{
keyExpression = new CodeSnippetExpression("\"" + ((ValueNode)targetObjectNode.XKeyNode.ItemNodes[0]).Value + "\"");
}
else
{
if (targetObjectNode.DictionaryKeyProperty == null)
{
throw new NotSupportedException("No key on dictionary entry");
}
throw new NotImplementedException();
}
cs = new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IDictionary), targetExpression), "Add", keyExpression, valueExpression));
}
else
{
if (!typeof(IList).IsAssignableFrom(parentType.UnderlyingType))
{
throw new NotImplementedException("Support non-IList adds");
}
//TODO: calling Add directly is how I'll leave it for now...
//cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IList), targetExpression), "Add", valueExpression));
cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(targetExpression, "Add", valueExpression));
}
}
else if (member.Member.IsEvent)
{
throw new NotImplementedException();
}
else
{
if (member.Member.IsAttachable)
{
cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(member.Member.DeclaringType.UnderlyingType.Name),
"Set" + member.Member.Name), targetExpression, valueExpression));
}
else //normal property
{
cs = new CodeAssignStatement(
new CodePropertyReferenceExpression(targetExpression, member.Member.Name), valueExpression);
}
}
initComponentMethod.Statements.Add(cs);
}
private void GenerateMemberAssignmentWithProvideValueIfNecessary(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode,
MemberNode parentMember, CodeVariableReferenceExpression cvre)
{
//if (parentMember.Member.IsUnknown)
//{
// throw new Exception("Unknown member " + parentMember.Member.Name);
//}
var xamlType = targetObjectNode.Type;
if (xamlType.IsMarkupExtension)
{
GenerateMemberAssignment(initComponentMethod, parentMember, parentExpression,
new CodeMethodInvokeExpression(cvre, "ProvideValue", new CodeVariableReferenceExpression("context"))
, targetObjectNode);
}
else
{
GenerateMemberAssignment(initComponentMethod, parentMember, parentExpression, cvre, targetObjectNode);
}
}
private void GenerateObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
string targetName;
var isPublicObject = false;
if (targetObjectNode.XNameNode == null)
{
targetName = GenerateUniqueName(targetObjectNode.Type);
}
else
{
var valueNode = targetObjectNode.XNameNode.ItemNodes[0] as ValueNode;
targetName = (string)valueNode.Value;
isPublicObject = true;
}
CodeExpression ctor = null;
if (targetObjectNode.XInitNode != null)
{
var tcName = GenerateTypeConverter(initComponentMethod, targetObjectNode.Type); // TextSyntax
ctor = GetTypeConverteredValue(targetObjectNode.Type, ((ValueNode)targetObjectNode.XInitNode.ItemNodes[0]).Value, targetObjectNode.Type.UnderlyingType, tcName);
}
else if (targetObjectNode.XFactoryMethodNode != null)
{
throw new NotImplementedException();
}
else if (targetObjectNode.XPosParamsNode != null)
{
var types = targetObjectNode.Type.GetPositionalParameters(targetObjectNode.XPosParamsNode.ItemNodes.Count);
var constructor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name);
for (var i = 0; i < types.Count; i++)
{
var tcName = GenerateTypeConverter(initComponentMethod, types[i]);
constructor.Parameters.Add(GetTypeConverteredValue(types[i], ((ValueNode)targetObjectNode.XPosParamsNode.ItemNodes[i]).Value, types[i].UnderlyingType, tcName));
}
ctor = constructor;
}
else if (targetObjectNode.XArgumentsNode != null)
{
throw new NotImplementedException();
}
else
{
if (targetObjectNode.Type.IsUnknown)
{
throw new Exception("Unknown type " + targetObjectNode.Type.Name + " found.");
}
ctor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name);
}
if (!isPublicObject)
{
var cvds = new CodeVariableDeclarationStatement(targetObjectNode.Type.UnderlyingType.Name, targetName, ctor);
initComponentMethod.Statements.Add(cvds);
}
else
{
var cas = new CodeAssignStatement(new CodeVariableReferenceExpression(targetName), ctor);
initComponentMethod.Statements.Add(cas);
// Needs to be public
PublicObjects.Add(targetName, targetObjectNode);
}
var cvre = new CodeVariableReferenceExpression(targetName);
var isUsuable = GetIsUsableDuringInitialization(targetObjectNode.Type);
if (isUsuable)
{
GenerateMemberAssignmentWithProvideValueIfNecessary(initComponentMethod, parentExpression, targetObjectNode, parentMember, cvre);
}
AddMembers(initComponentMethod, cvre, targetObjectNode);
if (!isUsuable)
{
GenerateMemberAssignmentWithProvideValueIfNecessary(initComponentMethod, parentExpression, targetObjectNode, parentMember, cvre);
}
}
private void GenerateGetObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
if (parentMember.Member.IsAttachable)
{
throw new NotImplementedException();
}
var cpfe = new CodePropertyReferenceExpression(parentExpression, parentMember.Member.Name);
var type = parentMember.Member.Type.UnderlyingType;
var targetName = GenerateUniqueName(type);
var cvds = new CodeVariableDeclarationStatement(type.Name, targetName, cpfe);
initComponentMethod.Statements.Add(cvds);
var cvre = new CodeVariableReferenceExpression(targetName);
AddMembers(initComponentMethod, cvre, targetObjectNode);
}
// MyData myDataObject = new MyData(DateTime.Now);
// Binding myBinding = new Binding("MyDataProperty");
// myBinding.Source = myDataObject;
// myText.SetBinding(TextBlock.TextProperty, myBinding);
private void GenerateBindingObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
// Generate new binding name
var targetName = GenerateUniqueName(targetObjectNode.Type);
var elementName = string.Empty;
var path = string.Empty;
// Grab all the attributes of the binding
var members = targetObjectNode.MemberNodes;
foreach (var member in members)
{
switch (member.Member.Name)
{
case "ElementName":
elementName = ExtractItemMemberValue(member.ItemNodes[0]);
break;
case "Path":
path = ExtractItemMemberValue(member.ItemNodes[0]);
break;
}
}
// Create a constructor for the binding adding the Path, if it exists
CodeExpression ctor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name, new CodePrimitiveExpression(path));
var cvds = new CodeVariableDeclarationStatement(targetObjectNode.Type.UnderlyingType.Name, targetName, ctor);
initComponentMethod.Statements.Add(cvds);
// Set the source property on the binding
CodeStatement cs = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(targetName), "Source"),
new CodeVariableReferenceExpression(elementName));
initComponentMethod.Statements.Add(cs);
// Set the binding on the target object
var cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(parentMember.ParentObjectNode.Type.UnderlyingType), parentMember.Member.Name + "Property");
var cmie = new CodeMethodInvokeExpression(parentExpression, "SetBinding", cfre, new CodeVariableReferenceExpression(targetName));
initComponentMethod.Statements.Add(cmie);
}
private void AddMembers(CodeMemberMethod initComponentMethod, CodeExpression targetExpression, CodeDomObjectNode objectNode)
{
var members = objectNode.MemberNodes;
foreach (var member in members)
{
if (member.Member.Name == "Implementation")
{
GenerateImplementation(initComponentMethod, member, targetExpression);
}
else
{
GenerateMemberValue(initComponentMethod, member, targetExpression);
}
}
}
