private static void ProcessNode(ZComponent parent, IList parent_list, TreeNodeCollection parent_nodes, XmlNode xmlNode)
{
if (xmlNode == null) return;
//Console.WriteLine("Processing: {0}", xmlNode.Name);
ZComponent comp = parent;
IList list = null;
if (xmlNode.Name == "ZApplication")
{
SetFields(comp, xmlNode);
}
else
{
// Check if this node is a List property of the parent
FieldInfo fi = parent.GetType().GetField(xmlNode.Name, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance);
//if (pi != null) Console.WriteLine(" Parent property found: {0}", pi.PropertyType.Name);
if (parent is ZComponent && fi != null && typeof(IList).IsAssignableFrom(fi.FieldType))
{
//Console.WriteLine("List found: {0}", xmlNode.Name);
list = (IList) fi.GetValue(parent);
}
// Check if this node is a ZCode property of the parent
else if (parent is ZComponent && fi != null && typeof(CodeLike).IsAssignableFrom(fi.FieldType))
{
CodeLike code = (CodeLike) fi.GetValue(parent); // Activator.CreateInstance(fi.FieldType);
code.Text = xmlNode.InnerText;
//code.Owner = parent;
Console.WriteLine("Code Text:\n{0}", code.Text);
fi.SetValue(comp, code);
//ZComponent.App.AddComponent(code);
return; //no TreeNode should be created for this
}
else
{
comp = CreateComponent(xmlNode.Name, xmlNode, parent, parent_list);
if (comp == null)
{
Console.WriteLine("SKIPPING subtree - Cannot find type: {0}", xmlNode.Name);
return;
}
}
}
TreeNode treeNode = null;
if (parent_nodes != null)
{
string displayName = xmlNode.Name;
XmlAttribute attribute = xmlNode.Attributes["Name"];
if (attribute != null)
displayName = displayName + " - " + attribute.Value;
treeNode = new TreeNode(displayName);
parent_nodes.Add(treeNode);
// clear subtree
if (treeNode != null) treeNode.Nodes.Clear();
}
// recursively build SubTree
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
if (treeNode != null)
ProcessNode(comp, list, treeNode.Nodes, childNode);
else
ProcessNode(comp, list, null, childNode);
}
}
// construct ZNodeProperties object for the TreeNode and assign it to Tag property
object target = (object) list ?? (object) comp;
object parentObj = (object) parent_list ?? (object) parent;
ZNodeProperties props = new ZNodeProperties(target, parentObj, xmlNode, treeNode);
if (list == null) comp.Tag = props;
if (_treeView != null)
{
treeNode.Tag = props;
ZTreeView.HighlightTreeNode(treeNode, props);
//props.XmlNodePropertyChanged += new XmlNodePropertyChangedEventHandler(_treeView.UpdateNodeText);
}
}
public void AddChildElement(TreeNode parentNode, Type childType)
{
if (treeView == null || parentNode == null || childType == null) return;
Console.WriteLine("Add child called {0}", childType.Name);
ZNodeProperties parentProps = parentNode.Tag as ZNodeProperties;
if (parentProps == null) return;
string childNodeName = childType.Name;
if (childType.BaseType == typeof(Model)) // this is a GameObject
childNodeName = "GameObject";
try
{
string modelName = null;
if (childNodeName == "Model")
{
DialogResult res = DialogHelper.InputBox("Model name", "Enter Model name:", ref modelName);
if (res == DialogResult.Cancel || modelName.Length == 0 || app.Find(modelName) != null)
{
Console.WriteLine("Invalid model name: \"{0}\"", modelName);
return;
}
}
XmlNode xmlNode = parentProps.xmlNode;
// Create new leaf node
XmlNode newXmlNode = xmlNode.OwnerDocument.CreateNode(XmlNodeType.Element, childNodeName, xmlNode.NamespaceURI);
string currentGuid = Guid.NewGuid().ToString();
nodeMap[newXmlNode] = currentGuid;
xmlNode.AppendChild(newXmlNode);
TreeNode newTreeNode = new TreeNode(childNodeName);
parentNode.Nodes.Add(newTreeNode);
ZComponent parent = parentProps.Component;
if (parent == null) parent = parentProps.Parent as ZComponent; // component is a List
ZComponent comp = null;
if (childType.BaseType == typeof(Model)) // this is a GameObject
{
// clone the corresponding Model
Model prototype = app.FindPrototypeByType(childType);
if (prototype == null)
{
Console.WriteLine("Cannot find prototype for {0}", childType.Name);
return;
}
comp = prototype.CreateClone(parent);
// assign Model attribute to the XmlNode
XmlAttribute newAttribute = newXmlNode.OwnerDocument.CreateAttribute("Model");
newAttribute.Value = prototype.Name;
newXmlNode.Attributes.Append(newAttribute);
//editor.RefreshSceneTreeview();
}
else
{
comp = CreateComponent(childType, parent, parentProps.List);
if (childNodeName == "Model")
{
Model model = comp as Model;
if (model != null) model.GUID = currentGuid;
XmlAttribute nameAttribute = newXmlNode.OwnerDocument.CreateAttribute("Name");
nameAttribute.Value = modelName;
newXmlNode.Attributes.Append(nameAttribute);
model.Name = modelName;
newTreeNode.Text = String.Format("{0} - {1}", childNodeName, modelName);
}
// create child XML nodes for generic member lists
foreach (FieldInfo fi in comp.GetType().GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
// Check if this field is a List
//if (fi.FieldType.IsGenericType && fi.FieldType.GetGenericTypeDefinition() == typeof(List<>))
if (fi != null && typeof(IList).IsAssignableFrom(fi.FieldType) && fi.Name != "Children" && fi.Name != "OwnerList")
{
Console.WriteLine("List node created: {0}", fi.Name);
XmlNode childXmlNode = newXmlNode.OwnerDocument.CreateNode(XmlNodeType.Element, fi.Name, newXmlNode.NamespaceURI);
newXmlNode.AppendChild(childXmlNode);
nodeMap[childXmlNode] = Guid.NewGuid().ToString();
}
}
}
// build subtree for member lists
int i = 0;
foreach (XmlNode childNode in newXmlNode.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
i = ProcessNode(comp, null, i, newTreeNode.Nodes, childNode);
}
}
// construct ZNodeProperties object for the TreeNode and assign it to Tag property
object parentObj = (object) parentProps.List ?? (object) parent;
ZNodeProperties props = new ZNodeProperties(comp, parentObj , newXmlNode, newTreeNode);
comp.Tag = props;
newTreeNode.Tag = props;
//props.XmlNodePropertyChanged += new XmlNodePropertyChangedEventHandler(treeView.UpdateNodeText);
ZTreeView.HighlightTreeNode(newTreeNode, props);
ZTreeView.HighlightTreeNode(parentNode, parentProps);
parentNode.Expand();
newTreeNode.Expand();
treeView.SelectedNode = newTreeNode;
// Tree node properties have been updated
// Force parent to reload them to the PropertyBrowser
//treeView.OnPropertiesChanged();
treeView.Invalidate();
Console.WriteLine("Component added: {0}", childType.Name);
treeView.StatusString = "Child node added";
OnXMLChanged();
// Recompilation is necessary if a new Model was added
if (childNodeName == "Model")
if (editor != null) editor.compileCodeBtn_Click(this, null);
}
catch (Exception ex)
{
treeView.StatusString = "Exception occurred: " + ex.Message;
Console.WriteLine(ex.ToString());
}
}
public void UpdateAttribute(ZNodeProperties props, string propName, object newValue)
{
XmlNode xmlNode = props.xmlNode;
if (xmlNode == null) return;
XmlAttribute attribute = xmlNode.Attributes[propName];
string str = Factory.Serialize(newValue);
if (attribute == null)
{
XmlAttribute newAttribute = xmlNode.OwnerDocument.CreateAttribute(propName);
newAttribute.Value = str;
xmlNode.Attributes.Append(newAttribute);
}
else
attribute.Value = str;
}
private int ProcessNode(ZComponent parent, IList parent_list, int next_index, TreeNodeCollection parent_nodes, XmlNode xmlNode)
{
//if (xmlNode == null) return;
//Console.WriteLine("Processing: {0}", xmlNode.Name);
ZComponent comp = parent;
IList list = null;
if (xmlNode.Name == "ZApplication")
{
//SetFields(comp, xmlNode);
}
else
{
// Check if this node is a List property of the parent
FieldInfo fi = CodeGenerator.GetField(parent.GetType(), xmlNode.Name);
//if (pi != null) Console.WriteLine(" Parent property found: {0}", pi.PropertyType.Name);
if (fi != null && typeof(IList).IsAssignableFrom(fi.FieldType))
{
//Console.WriteLine("List found: {0}", xmlNode.Name);
list = (IList) fi.GetValue(parent);
}
// Check if this node is an event of the parent
else if (fi != null && typeof(Delegate).IsAssignableFrom(fi.FieldType))
{
return next_index; //no TreeNode was created for this event
}
// Check if this node is a ZCode property of the parent
else if (fi != null && typeof(CodeLike).IsAssignableFrom(fi.FieldType))
{
return next_index; //no TreeNode was created for this CodeLike component
}
else
{
// Find the component in the list or among the children
comp = null;
IList findList = (IList) parent.Children;
if (parent_list != null) findList = parent_list; // parent_list has the priority
for (int index = next_index; index < findList.Count; index++)
{
ZComponent candidate = findList[index] as ZComponent;
if (IsCompatibleType(candidate, xmlNode))
{
comp = candidate;
next_index = index + 1;
break;
}
}
if (comp == null)
{
Console.WriteLine("SKIPPING subtree - Cannot find matching component: {0}", xmlNode.Name);
return next_index;
}
}
}
TreeNode treeNode = null;
if (parent_nodes != null)
{
string displayName = xmlNode.Name;
XmlAttribute attribute = xmlNode.Attributes["Name"];
if (attribute != null)
displayName = displayName + " - " + attribute.Value;
treeNode = new TreeNode(displayName);
parent_nodes.Add(treeNode);
// clear subtree
if (treeNode != null) treeNode.Nodes.Clear();
}
// recursively build SubTree
int i = 0;
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
i = ProcessNode(comp, list, i, treeNode.Nodes, childNode);
}
}
// construct ZNodeProperties object for the TreeNode and assign it to Tag property
object target = (object) list ?? (object) comp;
object parentObj = (object) parent_list ?? (object) parent;
ZNodeProperties props = new ZNodeProperties(target, parentObj, xmlNode, treeNode);
if (list == null) comp.Tag = props;
if (treeView != null)
{
treeNode.Tag = props;
ZTreeView.HighlightTreeNode(treeNode, props);
//props.XmlNodePropertyChanged += new XmlNodePropertyChangedEventHandler(treeView.UpdateNodeText);
}
return next_index;
}
public void DeleteComponent(ZNodeProperties props)
{
ZComponent comp = props.Component;
if (comp == null) return;
nodeMap.Remove(props.xmlNode);
ZComponent.App.RemoveComponent(comp); // remove the old component
// We should always set the Owner <= old Owner has been copied to newObj
comp.SetOwner(null, null); // delete references from OwnerList or from Owner's Children
// If the comp was selected in the editor, then clear that reference
if (editor.SelectedComponent == comp)
editor.SelectedComponent = null;
if (app.SelectedObject == comp)
app.SelectedObject = null;
// Delete named references from the app
if (comp.HasName())
{
FieldInfo fi = app.GetType().GetField(comp.Name, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (fi != null && fi.FieldType == comp.GetType())
{
Console.WriteLine("Nulling named reference {0} / {1}", fi.Name, fi.FieldType.Name);
fi.SetValue(app, null);
}
}
if (typeof(Model).IsAssignableFrom(comp.GetType()))
{
Model newMod = comp as Model;
ZComponent.App.RemoveModel(newMod);
// Refresh scene treeview in the editor (only necessary for GameObjects)
//if (newMod != null && newMod.Prototype == false)
//editor.RefreshSceneTreeview();
}
props.Component = null;
if (comp.HasName())
Console.WriteLine("Component deleted: {0}", comp.Name);
else
Console.WriteLine("Component deleted.");
}
public void SetCode(CodeLike code, ZComponent parent, string propertyName)
{
codeIsEvent = false;
currentCode = code;
if (parent != null) codeProperties = parent.Tag as ZNodeProperties;
codePropertyName = propertyName;
}
public void SetEventCode(ZComponent parent, string propertyName, TextEditorControl codeBox)
{
if (parent != null)
{
codeIsEvent = true;
currentCode = app.FindEvent(parent, propertyName) as CodeLike;
// CodeTextChanged will do nothing since codeProperties and codePropertyName are null
codeBox.Text = (currentCode != null) ? currentCode.Text : null;
codeProperties = parent.Tag as ZNodeProperties;
codePropertyName = propertyName;
}
}
public void ClearCode()
{
currentCode = null;
codeProperties = null;
codePropertyName = null;
codeIsEvent = false;
}
/// <summary>
/// Handles the XmlNodePropertyChanged event of selected TreeNode (with underlying XmlNode).
/// Commits changes to the TreeView.
/// Raises the ContentChanged event so to notifies the subscribers that
/// document content have been changed.
/// </summary>
/// <param name="sender">ZNodeProperties structure which has been modified.</param>
/// <param name="e">event argument (not used).</param>
internal void UpdateNodeText(ZNodeProperties props)
{
// Modifications through properties: use selected node as default
TreeNode treeNode = SelectedNode;
if (treeNode.Tag != props)
{
Console.WriteLine("TreeNode tag mismatch");
treeNode = FindNodeWithTag(Nodes, props);
}
if (treeNode != null && props.DisplayName.CompareTo(treeNode.Text) != 0)
{
// Rename tree node
treeNode.Text = props.DisplayName;
Invalidate();
}
//StatusString = e.StatusString;
}
/// <summary>
/// Event handler - deletes the selected node
/// </summary>
/*public void DeleteElement_Click(object sender, EventArgs e)
{
TreeNode treeNodeToDelete = SelectedNode;
TreeNode parentNode = treeNodeToDelete.Parent;
ZNodeProperties props = treeNodeToDelete.Tag as ZNodeProperties;
if (props != null)
{
if (project != null) project.DeleteComponent(props);
props.Delete();
treeNodeToDelete.Remove();
// Update parent node properties and type
if (parentNode.Nodes.Count == 0)
{
ZNodeProperties parentProps = (ZNodeProperties) parentNode.Tag;
//parentProperties.ConstructProperties();
HighlightTreeNode(parentNode, parentProps);
}
SelectedNode = parentNode;
// Tree node properties have been updated
// Force parent to reload them to the PropertyBrowser
//OnPropertiesChanged();
}
Invalidate();
}*/
/// <summary>
/// This method creates new tree node and appends
/// new xml node to the underlying xml document.
/// </summary>
/// <param name="parentNode">Parent Tree node to add a child to.</param>
/*private void AddChildNode(TreeNode parentNode, String childName)
{
StatusString = "Adding child node...";
ZNodeProperties parentNodeProperties = parentNode.Tag as ZNodeProperties;
TreeNode newTreeNode = new TreeNode(childName);
ZNodeProperties newNodeProperties = null;
if (parentNodeProperties != null)
{
newNodeProperties = parentNodeProperties.AddNewChild(childName, newTreeNode);
if (newNodeProperties != null)
{
newTreeNode.Tag = newNodeProperties;
newNodeProperties.XmlNodePropertyChanged += new XmlNodePropertyChangedEventHandler(this.XmlPropertiesUpdatedHandler);
parentNode.Nodes.Add(newTreeNode);
// Update parent node properties and type
//parentNodeProperties.ConstructProperties();
HighlightTreeNode(parentNode, parentNodeProperties);
HighlightTreeNode(newTreeNode, newNodeProperties);
parentNode.Expand();
this.SelectedNode = newTreeNode;
// Tree node properties have been updated
// Force parent to reload them to the PropertyBrowser
OnPropertiesChanged();
}
}
StatusString = "Child node added";
Invalidate();
}*/
/// <summary>
/// FineTune displaying TreeNode with ImageList and ForeColor properties
/// based on XmlNode's NodeType and Children Nodes Type/Count.
/// </summary>
internal static void HighlightTreeNode(TreeNode treeNode, ZNodeProperties treeNodeProperties)
{
if (treeNode != null && treeNodeProperties != null)
{
treeNode.ForeColor = treeNodeProperties.NodeForeColor;
treeNode.ImageIndex = treeNode.SelectedImageIndex = (int) treeNodeProperties.NodeImageIndex;
}
}
