protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { Controller.SaveNode(xmlDoc, nodeElement, context); var outEl = xmlDoc.CreateElement("Name"); outEl.SetAttribute("value", NickName); nodeElement.AppendChild(outEl); outEl = xmlDoc.CreateElement("Description"); outEl.SetAttribute("value", Description); nodeElement.AppendChild(outEl); outEl = xmlDoc.CreateElement("Inputs"); foreach (string input in InPortData.Select(x => x.NickName)) { XmlElement inputEl = xmlDoc.CreateElement("Input"); inputEl.SetAttribute("value", input); outEl.AppendChild(inputEl); } nodeElement.AppendChild(outEl); outEl = xmlDoc.CreateElement("Outputs"); foreach (string output in OutPortData.Select(x => x.NickName)) { XmlElement outputEl = xmlDoc.CreateElement("Output"); outputEl.SetAttribute("value", output); outEl.AppendChild(outputEl); } nodeElement.AppendChild(outEl); }
SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { //Don't copy over stored references if (context == SaveContext.Copy) return; //Only save elements in the home workspace if (WorkSpace is CustomNodeWorkspaceModel) return; foreach (var run in elements) { var outEl = xmlDoc.CreateElement("Run"); foreach (var id in run) { Element e; if (dynUtils.TryGetElement(id, out e)) { var elementStore = xmlDoc.CreateElement("Element"); elementStore.InnerText = e.UniqueId; outEl.AppendChild(elementStore); } } nodeElement.AppendChild(outEl); } }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { //Debug.WriteLine(pd.Object.GetType().ToString()); XmlElement outEl = xmlDoc.CreateElement(typeof(double).FullName); outEl.SetAttribute("value", port.PortName); nodeElement.AppendChild(outEl); }
//public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args) //{ // dynRevitSettings.ElementsContainers.Push(ElementsContainer); // var result = base.Evaluate(args); // dynRevitSettings.ElementsContainers.Pop(); // return result; //} protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { base.SaveNode(xmlDoc, nodeElement, context); if (context == SaveContext.Copy) return; foreach (var node in ElementsContainer.Nodes) { var outEl = xmlDoc.CreateElement("InnerNode"); outEl.SetAttribute("id", node.ToString()); foreach (var run in ElementsContainer[node]) { var runEl = xmlDoc.CreateElement("Run"); foreach (var id in run) { Element e; if (dynUtils.TryGetElement(id, out e)) { var elementStore = xmlDoc.CreateElement("Element"); elementStore.InnerText = e.UniqueId; runEl.AppendChild(elementStore); } } outEl.AppendChild(runEl); } nodeElement.AppendChild(outEl); } }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); //Base implementation must be called var formStringNode = element.OwnerDocument.CreateElement("FormulaText"); formStringNode.InnerText = FormulaString; element.AppendChild(formStringNode); }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); // Base implementation must be called. var helper = new XmlElementHelper(element); helper.SetAttribute("exportedUnit", SelectedExportedUnit.ToString()); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { base.DeserializeCore(element, context); //Base implementation must be called if (context == SaveContext.Undo) { //Reads in the new number of ports required from the data stored in the Xml Element //during Serialize (nextLength). Changes the current In Port Data to match the //required size by adding or removing port data. int currLength = InPortData.Count; XmlNodeList inNodes = element.SelectNodes("Input"); int nextLength = inNodes.Count; if (nextLength > currLength) { for (; currLength < nextLength; currLength++) { XmlNode subNode = inNodes.Item(currLength); string nickName = subNode.Attributes["name"].Value; InPortData.Add(new PortData(nickName, "", typeof(object))); } } else if (nextLength < currLength) InPortData.RemoveRange(nextLength, currLength - nextLength); RegisterAllPorts(); } }
protected override void SerializeCore(XmlElement element, SaveContext context) { var helper = new XmlElementHelper(element); helper.SetAttribute("guid", GUID); helper.SetAttribute("text", Text); helper.SetAttribute("x", X); helper.SetAttribute("y", Y); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { var helper = new XmlElementHelper(nodeElement); GUID = helper.ReadGuid("guid", GUID); Text = helper.ReadString("text", "New Note"); X = helper.ReadDouble("x", 0.0); Y = helper.ReadDouble("y", 0.0); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { XmlElementHelper helper = new XmlElementHelper(element); this.GUID = helper.ReadGuid("guid", this.GUID); this.Text = helper.ReadString("text", "New Note"); this.X = helper.ReadDouble("x", 0.0); this.Y = helper.ReadDouble("y", 0.0); }
protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); XmlElement outEl = nodeElement.OwnerDocument.CreateElement(typeof(string).FullName); var helper = new XmlElementHelper(outEl); helper.SetAttribute("value", SerializeValue()); nodeElement.AppendChild(outEl); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { var helper = new XmlElementHelper(nodeElement); GUID = helper.ReadGuid("guid", GUID); Text = helper.ReadString("text", "New Note"); X = helper.ReadDouble("x", 0.0); Y = helper.ReadDouble("y", 0.0); // Notify listeners that the position of the note has changed, // then parent group will also redraw itself. ReportPosition(); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { base.DeserializeCore(nodeElement, context); foreach (XmlNode subNode in nodeElement.ChildNodes) { if (subNode.Name.Equals(typeof(string).FullName)) { foreach (XmlAttribute attr in subNode.Attributes) { if (attr.Name.Equals("value")) { Value = DeserializeValue(attr.Value); } } } } }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { base.DeserializeCore(nodeElement, context); //Base implementation must be called if (nodeElement.Attributes != null) { var formulaAttr = nodeElement.Attributes["formula"]; if (formulaAttr != null) { FormulaString = formulaAttr.Value; return; } } var formStringNode = nodeElement.ChildNodes.Cast<XmlNode>().FirstOrDefault(childNode => childNode.Name == "FormulaText"); FormulaString = formStringNode != null ? formStringNode.InnerText : nodeElement.InnerText; }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); VarInputController.SerializeCore(element, context); }
public void SerializeCore(XmlElement element, SaveContext context) { //base.SerializeCore(element, context); //Base implementation must be called SerializeInputCount(element, model.InPortData.Count); }
/// <summary> /// Deserializes object /// </summary> /// <param name="element">xml node</param> /// <param name="context">save context</param> public void DeserializeCore(XmlElement element, SaveContext context) { int amt = Convert.ToInt32(element.Attributes["inputcount"].Value); SetNumInputs(amt); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("AdjacentSpanWeightIncreaseType", AdjacentSpanWeightIncreaseType); }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { if (context == SaveContext.Copy || context == SaveContext.Undo) { //Dump all the information into memory nodeElement.SetAttribute("inputCount", this.InputCount.ToString()); nodeElement.SetAttribute("outputCount", this.OutputCount.ToString()); nodeElement.SetAttribute("legacyNodeName", this.LegacyNodeName); nodeElement.SetAttribute("legacyAssembly", this.LegacyAssembly); nodeElement.SetAttribute("nodeNature", this.NodeNature.ToString()); if (this.OriginalNodeContent != null) { XmlElement originalNode = xmlDoc.CreateElement("OriginalNodeContent"); XmlElement nodeContent = nodeElement.OwnerDocument.CreateElement(this.OriginalNodeContent.Name); foreach (XmlAttribute attribute in this.OriginalNodeContent.Attributes) { nodeContent.SetAttribute(attribute.Name, attribute.Value); } for (int i = 0; i < this.OriginalNodeContent.ChildNodes.Count; i++) { XmlNode child = nodeContent.OwnerDocument.ImportNode(this.OriginalNodeContent.ChildNodes[i], true); nodeContent.AppendChild(child.CloneNode(true)); } originalNode.AppendChild(nodeContent); nodeElement.AppendChild(originalNode); } } if (context == SaveContext.File) { //When save files, only save the original node's content, //instead of saving the dummy node. if (this.OriginalNodeContent != null) { XmlElement originalNode = nodeElement.OwnerDocument.CreateElement(this.OriginalNodeContent.Name); foreach (XmlAttribute attribute in this.OriginalNodeContent.Attributes) { originalNode.SetAttribute(attribute.Name, attribute.Value); } //overwrite the guid/x/y value of the original node. originalNode.SetAttribute("guid", nodeElement.GetAttribute("guid")); originalNode.SetAttribute("x", nodeElement.GetAttribute("x")); originalNode.SetAttribute("y", nodeElement.GetAttribute("y")); for (int i = 0; i < this.OriginalNodeContent.ChildNodes.Count; i++) { XmlNode child = originalNode.OwnerDocument.ImportNode(this.OriginalNodeContent.ChildNodes[i], true); originalNode.AppendChild(child.CloneNode(true)); } nodeElement.ParentNode.ReplaceChild(originalNode, nodeElement); } else { nodeElement.SetAttribute("inputCount", this.InputCount.ToString()); nodeElement.SetAttribute("outputCount", this.OutputCount.ToString()); nodeElement.SetAttribute("legacyNodeName", this.LegacyNodeName); nodeElement.SetAttribute("legacyAssembly", this.LegacyAssembly); nodeElement.SetAttribute("nodeNature", this.NodeNature.ToString()); } } }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); element.SetAttribute("project", project); element.SetAttribute("key", key); }
protected abstract void SerializeCore(XmlElement element, SaveContext context);
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("SnowThermalCase", SnowThermalCaseId); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { // We are not deserializing the ports. throw new NotImplementedException(); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("BeamDeflectionCaseId", BeamDeflectionCaseId); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("ClearCoverCaseId", ClearCoverCaseId); }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); this.SaveNode(element.OwnerDocument, element, context); }
public override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { var asmPath = Definition.Assembly ?? ""; if (context == SaveContext.File) { // We only make relative paths in a file saving operation. var docPath = Utilities.GetDocumentXmlPath(xmlDoc); asmPath = Utilities.MakeRelativePath(docPath, asmPath); } nodeElement.SetAttribute("assembly", asmPath); nodeElement.SetAttribute("function", Definition.MangledName ?? ""); }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { nodeElement.SetAttribute("index", SelectedIndex.ToString()); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { // We are not deserializing the ports. throw new NotImplementedException(); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("ReferenceDesignValueType", ReferenceDesignValueType); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { List <XmlNode> childNodes = nodeElement.ChildNodes.Cast <XmlNode>().ToList(); if (!Controller.IsInSyncWithNode(this)) { Controller.SyncNodeWithDefinition(this); OnNodeModified(); } else if (Controller.Definition == null || Controller.Definition.IsProxy) { foreach (XmlNode subNode in childNodes) { if (subNode.Name.Equals("Outputs")) { var data = subNode.ChildNodes.Cast <XmlNode>() .Select( (outputNode, i) => new { data = new PortData(outputNode.Attributes[0].Value, Properties.Resources.ToolTipOutput + (i + 1)), idx = i }); foreach (var dataAndIdx in data) { if (OutPortData.Count > dataAndIdx.idx) { OutPortData[dataAndIdx.idx] = dataAndIdx.data; } else { OutPortData.Add(dataAndIdx.data); } } } else if (subNode.Name.Equals("Inputs")) { var data = subNode.ChildNodes.Cast <XmlNode>() .Select( (inputNode, i) => new { data = new PortData(inputNode.Attributes[0].Value, Properties.Resources.ToolTipInput + (i + 1)), idx = i }); foreach (var dataAndIdx in data) { if (InPortData.Count > dataAndIdx.idx) { InPortData[dataAndIdx.idx] = dataAndIdx.data; } else { InPortData.Add(dataAndIdx.data); } } } #region Legacy output support else if (subNode.Name.Equals("Output")) { var data = new PortData(subNode.Attributes[0].Value, Properties.Resources.ToolTipFunctionOutput); if (OutPortData.Any()) { OutPortData[0] = data; } else { OutPortData.Add(data); } } #endregion } RegisterAllPorts(); } base.DeserializeCore(nodeElement, context); //Base implementation must be called XmlNode nameNode = childNodes.LastOrDefault(subNode => subNode.Name.Equals("Name")); if (nameNode != null && nameNode.Attributes != null) { NickName = nameNode.Attributes["value"].Value; } XmlNode descNode = childNodes.LastOrDefault(subNode => subNode.Name.Equals("Description")); if (descNode != null && descNode.Attributes != null) { Description = descNode.Attributes["value"].Value; } }
/// <summary> /// Deserialize model from xml node. /// </summary> /// <param name="element">Xml node</param> /// <param name="context">Save context. E.g. save in file, copy node etc.</param> public void Deserialize(XmlElement element, SaveContext context) { DeserializeCore(element, context); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("EnclosingRebarDirection", EnclosingRebarDirection); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { base.DeserializeCore(element, context); //Base implementation must be called if (context != SaveContext.Undo) return; var helper = new XmlElementHelper(element); NickName = helper.ReadString("functionName"); Controller.DeserializeCore(element, context); XmlNodeList inNodes = element.SelectNodes("functionInput"); XmlNodeList outNodes = element.SelectNodes("functionOutput"); var inData = inNodes.Cast<XmlNode>() .Select( (inputNode, i) => new { data = new PortData(inputNode.Attributes[0].Value, "Input #" + (i + 1)), idx = i }); foreach (var dataAndIdx in inData) { if (InPortData.Count > dataAndIdx.idx) InPortData[dataAndIdx.idx] = dataAndIdx.data; else InPortData.Add(dataAndIdx.data); } var outData = outNodes.Cast<XmlNode>() .Select( (outputNode, i) => new { data = new PortData(outputNode.Attributes[0].Value, "Output #" + (i + 1)), idx = i }); foreach (var dataAndIdx in outData) { if (OutPortData.Count > dataAndIdx.idx) OutPortData[dataAndIdx.idx] = dataAndIdx.data; else OutPortData.Add(dataAndIdx.data); } //Added it the same way as LoadNode. But unsure of when 'Output' ChildNodes will //be added to element. As of now I dont think it is added during serialize #region Legacy output support foreach (var portData in from XmlNode subNode in element.ChildNodes where subNode.Name.Equals("Output") select new PortData(subNode.Attributes[0].Value, "function output")) { if (OutPortData.Any()) OutPortData[0] = portData; else OutPortData.Add(portData); } #endregion RegisterAllPorts(); Description = helper.ReadString("functionDesc"); }
/// <summary> /// Serializes object /// </summary> /// <param name="element">xml node</param> /// <param name="context">save context</param> public void SerializeCore(XmlElement element, SaveContext context) { SerializeInputCount(element, model.InPorts.Count); }
public NodeModel CreateNodeFromXml(XmlElement nodeElement, SaveContext context) { string assembly = ""; string function; var nickname = nodeElement.Attributes["nickname"].Value; FunctionDescriptor descriptor; Trace.Assert(nodeElement.Attributes != null, "nodeElement.Attributes != null"); if (nodeElement.Attributes["assembly"] == null) { assembly = DetermineAssemblyName(nodeElement); function = nickname.Replace(".get", "."); } else { string xmlSignature = nodeElement.Attributes["function"].Value; string hintedSigniture = libraryServices.FunctionSignatureFromFunctionSignatureHint(xmlSignature); if (hintedSigniture != null) { nodeElement.Attributes["nickname"].Value = libraryServices.NicknameFromFunctionSignatureHint(xmlSignature); function = hintedSigniture; // if the node needs additional parameters, add them here if (libraryServices.FunctionSignatureNeedsAdditionalAttributes(xmlSignature)) { libraryServices.AddAdditionalAttributesToNode(xmlSignature, nodeElement); } if (libraryServices.FunctionSignatureNeedsAdditionalElements(xmlSignature)) { libraryServices.AddAdditionalElementsToNode(xmlSignature, nodeElement); } } else { function = xmlSignature; } var xmlAttribute = nodeElement.Attributes["assembly"]; if (xmlAttribute != null) { assembly = Uri.UnescapeDataString(xmlAttribute.Value); } } if (context == SaveContext.File && !string.IsNullOrEmpty(assembly)) { var document = nodeElement.OwnerDocument; var docPath = Nodes.Utilities.GetDocumentXmlPath(document); assembly = Nodes.Utilities.MakeAbsolutePath(docPath, assembly); descriptor = libraryServices.IsLibraryLoaded(assembly) || libraryServices.ImportLibrary(assembly) ? libraryServices.GetFunctionDescriptor(assembly, function) : libraryServices.GetFunctionDescriptor(function); } else { descriptor = libraryServices.GetFunctionDescriptor(function); } if (null == descriptor) { var inputcount = DetermineFunctionInputCount(nodeElement); return(new DummyNode( inputcount, 1, nickname, nodeElement, assembly, DummyNode.Nature.Unresolved)); } DSFunctionBase result; if (descriptor.IsVarArg) { result = new DSVarArgFunction(descriptor); if (nodeElement.Name != typeof(DSVarArgFunction).FullName) { VariableInputNodeController.SerializeInputCount( nodeElement, descriptor.Parameters.Count()); } } else { result = new DSFunction(descriptor); } result.Deserialize(nodeElement, context); // In case of input parameters mismatch, use default arguments for parameters that have one if (!descriptor.MangledName.EndsWith(function)) { string[] oldSignature = function.Split('@'); string[] inputTypes = oldSignature.Length > 1 ? oldSignature[1].Split(',') : new string[] {}; int i = 0, j = 0; foreach (var param in descriptor.Parameters) { if (i >= inputTypes.Length || param.Type.ToString() != inputTypes[i]) { result.InPorts[j].UsingDefaultValue = result.InPortData[j].DefaultValue != null; } else { i++; } j++; } } return(result); }
/// <summary> ///Saves property values to be retained when opening the node /// </summary> protected override void SerializeCore(XmlElement nodeElement, SaveContext context) { base.SerializeCore(nodeElement, context); nodeElement.SetAttribute("ServiceMoistureCondition", ServiceMoistureCondition); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { base.DeserializeCore(element, context); var helper = new XmlElementHelper(element); var script = helper.ReadString("Script", string.Empty); this._script = script; }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { base.DeserializeCore(nodeElement, context); VariableInputController.DeserializeCore(nodeElement, context); }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); var helper = new XmlElementHelper(element); helper.SetAttribute("Script", this.Script); }
/// <summary> /// Creates and initializes a NodeModel from its Xml representation. /// </summary> /// <param name="elNode">XmlElement for a NodeModel.</param> /// <param name="context">The serialization context for initialization.</param> /// <param name="nodeFactory">A NodeFactory, to be used to create the node.</param> /// <returns></returns> public static NodeModel LoadNodeFromXml( XmlElement elNode, SaveContext context, NodeFactory nodeFactory) { return(nodeFactory.CreateNodeFromXml(elNode, context)); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { XmlElementHelper helper = new XmlElementHelper(element); this.GUID = helper.ReadGuid("guid", this.GUID); this.annotationText = helper.ReadString("annotationText", Resources.GroupDefaultText); this.X = helper.ReadDouble("left", DoubleValue); this.Y = helper.ReadDouble("top", DoubleValue); this.width = helper.ReadDouble("width", DoubleValue); this.height = helper.ReadDouble("height", DoubleValue); this.background = helper.ReadString("backgrouund", ""); this.fontSize = helper.ReadDouble("fontSize", fontSize); this.textBlockHeight = helper.ReadDouble("TextblockHeight", DoubleValue); this.InitialTop = helper.ReadDouble("InitialTop", DoubleValue); this.InitialHeight = helper.ReadDouble("InitialHeight", DoubleValue); //Deserialize Selected models if (element.HasChildNodes) { var listOfModels = new List<ModelBase>(); foreach (var childnode in element.ChildNodes) { XmlElementHelper mhelper = new XmlElementHelper(childnode as XmlElement); if (SelectedModels != null) { var result = mhelper.ReadGuid("ModelGuid", new Guid()); ModelBase model = null; model = ModelBaseRequested != null ? ModelBaseRequested(result) : SelectedModels.FirstOrDefault(x => x.GUID == result); listOfModels.Add(model); } } SelectedModels = listOfModels; } //On any Undo Operation, current values are restored to previous values. //These properties should be Raised, so that they get the correct value on Undo. RaisePropertyChanged("Background"); RaisePropertyChanged("FontSize"); RaisePropertyChanged("AnnotationText"); RaisePropertyChanged("SelectedModels"); }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { base.SaveNode(xmlDoc, nodeElement, context); var helper = new XmlElementHelper(nodeElement); helper.SetAttribute("CodeText", code); helper.SetAttribute("ShouldFocus", shouldFocus); }
public override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); var helper = new XmlElementHelper(element); helper.SetAttribute("name", Definition.MangledName); }
/// <summary> /// Serializes Controller information from XML. /// </summary> public virtual void SerializeCore(XmlElement element, SaveContext context) { }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); //Base implementation must be called if (context != SaveContext.Undo) return; var helper = new XmlElementHelper(element); helper.SetAttribute("functionId", Definition.FunctionId.ToString()); helper.SetAttribute("functionName", NickName); helper.SetAttribute("functionDesc", Description); XmlDocument xmlDoc = element.OwnerDocument; foreach (string input in InPortData.Select(x => x.NickName)) { XmlElement inputEl = xmlDoc.CreateElement("functionInput"); inputEl.SetAttribute("inputValue", input); element.AppendChild(inputEl); } foreach (string input in OutPortData.Select(x => x.NickName)) { XmlElement outputEl = xmlDoc.CreateElement("functionOutput"); outputEl.SetAttribute("outputValue", input); element.AppendChild(outputEl); } }
protected abstract void DeserializeCore(XmlElement nodeElement, SaveContext context);
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { //Debug.WriteLine(pd.Object.GetType().ToString()); XmlElement outEl = xmlDoc.CreateElement("Symbol"); outEl.SetAttribute("value", Symbol); nodeElement.AppendChild(outEl); }
protected override void SaveInternal(SaveContext saveContext) { throw new NotImplementedException(); }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { XmlElement script = xmlDoc.CreateElement("Script"); //script.InnerText = this.tb.Text; script.InnerText = _script; nodeElement.AppendChild(script); }
protected abstract void SaveInternal(SaveContext saveContext);
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { XmlElement script = xmlDoc.CreateElement("Script"); //script.InnerText = this.tb.Text; script.InnerText = _script; nodeElement.AppendChild(script); // save the number of inputs nodeElement.SetAttribute("inputs", (InPortData.Count).ToString()); }
public override void Save(SaveContext saveContext) { // Not actually an indirect to another object, as noted in Load, // so we're saving inline Content.Save(saveContext); }
void SerializeCore(XmlElement element, SaveContext context) { XmlElementHelper helper = new XmlElementHelper(element); helper.SetAttribute("guid", this.GUID); helper.SetAttribute("annotationText", this.AnnotationText); helper.SetAttribute("left", this.X); helper.SetAttribute("top", this.Y); helper.SetAttribute("width", this.Width); helper.SetAttribute("height", this.Height); helper.SetAttribute("fontSize", this.FontSize); helper.SetAttribute("InitialTop", this.InitialTop); helper.SetAttribute("InitialHeight", this.InitialHeight); helper.SetAttribute("TextblockHeight", this.TextBlockHeight); helper.SetAttribute("backgrouund", (this.Background == null ? "" : this.Background.ToString())); //Serialize Selected models XmlDocument xmlDoc = element.OwnerDocument; foreach (var guids in this.SelectedModels.Select(x => x.GUID)) { if (xmlDoc != null) { var modelElement = xmlDoc.CreateElement("Models"); element.AppendChild(modelElement); XmlElementHelper mhelper = new XmlElementHelper(modelElement); modelElement.SetAttribute("ModelGuid", guids.ToString()); } } }
protected override void SaveInternal(SaveContext saveContext) { saveContext.Utility.Write(Values.Count); saveContext.Utility.Write(Values.ToArray()); }
protected override void DeserializeCore(XmlElement element, SaveContext context) { base.DeserializeCore(element, context); if (context == SaveContext.Undo) { var helper = new XmlElementHelper(element); shouldFocus = helper.ReadBoolean("ShouldFocus"); code = helper.ReadString("CodeText"); ProcessCodeDirect(); } }
protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context) { base.SaveNode(xmlDoc, nodeElement, context); VarInputController.SaveNode(xmlDoc, nodeElement, context); }
protected override void SerializeCore(XmlElement element, SaveContext context) { base.SerializeCore(element, context); var helper = new XmlElementHelper(element); helper.SetAttribute("CodeText", code); helper.SetAttribute("ShouldFocus", shouldFocus); }
public void DeserializeCore(XmlElement nodeElement, SaveContext context) => base.DeserializeCore(nodeElement, context);