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");
}
/// <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);
}
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);
