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; } }