public override void Populate(SerializeableNodeViewModel node)
{
base.Populate(node);
SerializeableVariableNode v = node as SerializeableVariableNode;
this.Type = v.TypeString;
this.CallingClass = node.CallingClass;
}
public void LoadNodes()
{
ClearNodes();
OpenFileDialog openFileDialog1 = new OpenFileDialog();
// Set filter options and filter index.
openFileDialog1.Filter = "XML Files (.xml)|*.xml|All Files (*.*)|*.*";
openFileDialog1.FilterIndex = 1;
openFileDialog1.Multiselect = true;
// Call the ShowDialog method to show the dialog box.
bool?userClickedOK = openFileDialog1.ShowDialog();
// Process input if the user clicked OK.
if (userClickedOK == true)
{
List <SerializeableNodeViewModel> SerializeNodes = new List <SerializeableNodeViewModel>();
string path = openFileDialog1.FileName;
XmlSerializer ser = new XmlSerializer(typeof(List <SerializeableNodeViewModel>), new Type[] { typeof(SerializeableVariableNode), typeof(SerializeableConditionNode), typeof(SerializeableDynamicNode), typeof(SerializeableRootNode) });
using (XmlReader reader = XmlReader.Create(path))
{
SerializeNodes = (List <SerializeableNodeViewModel>)ser.Deserialize(reader);
}
//ADD NODES
foreach (var serializeableNodeViewModel in SerializeNodes)
{
if (serializeableNodeViewModel is SerializeableRootNode)
{
SerializeableRootNode rootSerialized = serializeableNodeViewModel as SerializeableRootNode;
RootNode newNode = new RootNode();
newNode.Populate(rootSerialized);
Nodes.Add(newNode);
}
if (serializeableNodeViewModel is SerializeableVariableNode)
{
SerializeableVariableNode variableSerialized = serializeableNodeViewModel as SerializeableVariableNode;
VariableNode newNode = new VariableNode();
newNode.Populate(variableSerialized);
Nodes.Add(newNode);
}
if (serializeableNodeViewModel is SerializeableDynamicNode)
{
SerializeableDynamicNode dynamicSerialized = serializeableNodeViewModel as SerializeableDynamicNode;
DynamicNode newNode = new DynamicNode();
newNode.Populate(dynamicSerialized);
Nodes.Add(newNode);
}
if (serializeableNodeViewModel is SerializeableConditionNode)
{
SerializeableConditionNode conSerialized = serializeableNodeViewModel as SerializeableConditionNode;
ConditionNode newNode = new ConditionNode();
newNode.Populate(conSerialized);
Nodes.Add(newNode);
}
}
}
//Node Connections
foreach (var node in Nodes)
{
if (node is RootNode)
{
//Connect output
RootNode rootNode = node as RootNode;
if (rootNode.OutputConnector.ConnectionNodeID <= 0)
{
return;
}
//Connect this output to the connection's input
Connector connectedTo = GetInConnectorBasedOnNode(rootNode.OutputConnector.ConnectionNodeID);
Connector.ConnectPins(rootNode.OutputConnector, connectedTo);
}
if (node is ConditionNode)
{
ConditionNode conNode = node as ConditionNode;
//bool value Input
if (conNode.boolInput.ConnectionNodeID > 0)
{
//we're connected to a parameter
Connector connectedToVar = GetOutConnectorBasedOnNode(conNode.boolInput.ConnectionNodeID); //variable
Connector.ConnectPins(conNode.boolInput, connectedToVar);
}
//Input
if (conNode.InExecutionConnector.ConnectionNodeID > 0)
{
Connector connectedTo = GetOutConnectorBasedOnNode(conNode.InExecutionConnector.ConnectionNodeID);
Connector.ConnectPins(conNode.InExecutionConnector, connectedTo);
}
//Ouput true
if (conNode.OutExecutionConnectorTrue.ConnectionNodeID > 0)
{
Connector connectedTo = GetInConnectorBasedOnNode(conNode.OutExecutionConnectorTrue.ConnectionNodeID);
Connector.ConnectPins(conNode.OutExecutionConnectorTrue, connectedTo);
}
//Ouput false
if (conNode.OutExecutionConnectorFalse.ConnectionNodeID > 0)
{
Connector connectedTo = GetInConnectorBasedOnNode(conNode.OutExecutionConnectorFalse.ConnectionNodeID);
Connector.ConnectPins(conNode.OutExecutionConnectorFalse, connectedTo);
}
}
if (node is DynamicNode)
{
//Connect output
DynamicNode dynNode = node as DynamicNode;
//Connect parameters
for (int i = 0; i < dynNode.ArgumentCache.Count(); i++)
{
Argument arg = dynNode.ArgumentCache.ElementAt(i);
if (arg.ArgIsExistingVariable)
{
Connector conID = dynNode.GetConnectorAtIndex(i);
int connectedToVar = arg.ArgumentConnectedToNodeID;
Connector varConnect = GetOutConnectorBasedOnNode(connectedToVar);
Connector.ConnectPins(conID, varConnect);
}
}
if (dynNode.OutExecutionConnector.ConnectionNodeID > 0)
{
//Connect this output to the connection's input
Connector connectedTo = GetInConnectorBasedOnNode(dynNode.OutExecutionConnector.ConnectionNodeID);
Connector.ConnectPins(dynNode.OutExecutionConnector, connectedTo);
//No need to connect this in to the connection's output so far.
}
}
}
}
public void SaveNodes()
{
Microsoft.Win32.SaveFileDialog saveFileDialog1 = new Microsoft.Win32.SaveFileDialog();
// Set filter options and filter index.
saveFileDialog1.Filter = "XML Files (.xml)|*.xml|All Files (*.*)|*.*";
saveFileDialog1.FilterIndex = 1;
string path = "";
// Call the ShowDialog method to show the dialog box.
bool?userClickedOK = saveFileDialog1.ShowDialog();
// Process input if the user clicked OK.
if (userClickedOK == true)
{
path = saveFileDialog1.FileName;
Stream myStream = saveFileDialog1.OpenFile();
if (myStream != null)
{
#region Nodes
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings()
{
Indent = true,
IndentChars = "\t",
NewLineOnAttributes = true
};
List <SerializeableNodeViewModel> SerializeNodes = new List <SerializeableNodeViewModel>();
XmlSerializer serializer = new XmlSerializer(typeof(List <SerializeableNodeViewModel>), new Type[] { typeof(SerializeableVariableNode), typeof(SerializeableConditionNode), typeof(SerializeableRootNode), typeof(SerializeableDynamicNode) });
TextWriter writer = new StreamWriter(myStream);
foreach (var node in Nodes)
{
if (node is RootNode)
{
RootNode rootNode = node as RootNode;
SerializeableRootNode rootSerial = new SerializeableRootNode();
rootSerial.NodeName = rootNode.NodeName;
rootSerial.NodeType = rootSerial.NodeType;
rootSerial.MarginX = rootNode.Margin.Left + rootNode.Transform.X;
rootSerial.MarginY = rootNode.Margin.Top + rootNode.Transform.Y;
rootSerial.ID = rootNode.ID;
rootSerial.OutputNodeID = rootNode.OutputConnector.ConnectionNodeID; //connection to next node
rootSerial.CallingClass = rootNode.CallingClass;
SerializeNodes.Add(rootSerial);
}
if (node is ConditionNode)
{
ConditionNode conNode = node as ConditionNode;
SerializeableConditionNode conSerial = new SerializeableConditionNode();
conSerial.NodeName = conNode.NodeName;
conSerial.NodeType = conNode.NodeType;
conSerial.MarginX = conNode.Margin.Left + conNode.Transform.X;
conSerial.MarginY = conNode.Margin.Top + conNode.Transform.Y;
conSerial.ID = conNode.ID;
conSerial.InputNodeID = conNode.InExecutionConnector.ConnectionNodeID;
conSerial.OutputTrueNodeID = conNode.OutExecutionConnectorTrue.ConnectionNodeID;
conSerial.OutputFalseNodeID = conNode.OutExecutionConnectorFalse.ConnectionNodeID;
conSerial.BoolVariableID = conNode.boolInput.ConnectionNodeID;
conSerial.BoolVariableName = conNode.ConnectedToVariableName;
conSerial.BoolCallingClass = conNode.ConnectedToVariableCallerClassName;
SerializeNodes.Add(conSerial);
}
if (node is VariableNode)
{
VariableNode varNode = node as VariableNode;
SerializeableVariableNode varSerial = new SerializeableVariableNode();
varSerial.NodeName = varNode.NodeName;
varSerial.TypeString = varNode.Type;
varSerial.NodeType = varNode.NodeType;
varSerial.MarginX = varNode.Margin.Left + varNode.Transform.X;
varSerial.MarginY = varNode.Margin.Top + varNode.Transform.Y;
varSerial.ID = varNode.ID;
varSerial.ConnectedToNodeID = varNode.NodeParameterOut.ConnectionNodeID;
varSerial.ConnectedToConnectorID = varNode.NodeParameterOut.ConnectedToConnectorID;
varSerial.CallingClass = varNode.CallingClass;
SerializeNodes.Add(varSerial);
}
if (node is DynamicNode)
{
DynamicNode dynNode = node as DynamicNode;
SerializeableDynamicNode dynSerial = new SerializeableDynamicNode();
dynSerial.NodeType = dynNode.NodeType;
dynSerial.NodeName = dynNode.NodeName;
dynSerial.Command = dynNode.Command;
dynSerial.NodePanelHeight = dynNode.NodeHeight;
dynSerial.MarginX = dynNode.Margin.Left + dynNode.Transform.X;
dynSerial.MarginY = dynNode.Margin.Top + dynNode.Transform.Y;
dynSerial.ID = dynNode.ID;
foreach (var arg in dynNode.ArgumentCache)
{
dynSerial.Arguments.Add(arg);
}
dynSerial.InputNodeID = dynNode.InConnector.ConnectionNodeID;
dynSerial.OutputNodeID = dynNode.OutConnector.ConnectionNodeID;
dynSerial.CallingClass = dynNode.CallingClass;
SerializeNodes.Add(dynSerial);
}
}
serializer.Serialize(writer, SerializeNodes);
writer.Close();
myStream.Close();
System.Windows.Clipboard.SetText(path);
MainViewModel.Instance.LogStatus("Save completed. Path: " + path + " copied to clipboard", true);
#endregion
}
}
}
