public override JObject classToJson(AbstractNodeClass nodeClass)
{
CombinedNodeClass combinedClass = nodeClass as CombinedNodeClass;
if (combinedClass == null)
{
return(null);
}
JObject root = new JObject();
AddOwnType(root);
AddName(root, nodeClass.Name);
AddDescription(root, nodeClass.Description);
AddDisplayName(root, nodeClass.DisplayName);
AddOutput(root, nodeClass.OutputType);
AddInputs(root, nodeClass.InputTypes);
AddProxyProperties(root, combinedClass.ProxyProperties);
AddUserCreated(root, nodeClass.UserCreated);
AddCreator(root, nodeClass.Creator);
AddConnections(root, combinedClass.Connections);
AddSubNodes(root, combinedClass.SubElements);
AddOutputNodeID(root, combinedClass.OutputNodeUuid);
return(root);
}
/// <summary>
/// This adds all Nodes to the node generation list.
/// </summary>
/// <param name="nodes">to add</param>
public void AddNodes(IEnumerable <Node> nodes)
{
if (nodes == null || !nodes.Any())
{
return;
}
this._nodes.AddRange(nodes);
this._cachedNodeClass = null;
}
/// <summary>
/// This adds a Node to the node generation list.
/// </summary>
/// <param name="node">to add</param>
public void AddNode(Node node)
{
if (node == null)
{
return;
}
this._nodes.Add(node);
this._cachedNodeClass = null;
}
/// <summary>
/// Generates the NodeClass.
/// </summary>
/// <returns>The node class or null if not possible.</returns>
public CombinedNodeClass GenerateClass()
{
if (_cachedNodeClass != null)
{
return(_cachedNodeClass);
}
var root = GetRootNode();
if (root == null)
{
return(null);
}
//Try to sort the Nodes:
List <Node> sorted = TrySortNodes();
//Generate Inputs + Sub-Hirachy.
var inputs = new List <DataType>();
var connections = new List <SimpleConnection>();
var subNodes = new List <SimpleSubNode>();
var centerX = sorted.Average(n => n.PosX);
var centerY = sorted.Average(n => n.PosY);
var input = 0;
foreach (var node in sorted)
{
var nodeClass = node.Class;
var nodeInputs = node.InputNodes;
subNodes.Add(new SimpleSubNode(node, centerX, centerY));
for (var i = 0; i < nodeInputs.Count(); i++)
{
var subNode = nodeInputs[i];
if (subNode == null || !_nodes.Contains(subNode))
{
inputs.Add(nodeClass.InputTypes[i]);
connections.Add(new SimpleConnection(node.NodeUUID, "input" + input, i));
input++;
}
else
{
connections.Add(new SimpleConnection(node.NodeUUID, subNode.NodeUUID, i));
}
}
}
//Generate the BaseNode:
var output = root.Class.OutputType;
var creator = Environment.UserName;
//Finally generate the NodeClass
var finalNodeClass = new CombinedNodeClass(Name, Name, Description, creator,
subNodes, connections, output, root.NodeUUID, true, Path.Combine(WorkSpace.DIR, WorkSpace.CREATED_DIR, Name.RemoveAll(" ", "_")),
inputs.ToArray());
this._cachedNodeClass = finalNodeClass;
return(finalNodeClass);
}
/// <summary>
/// Called when the Class property changed its value.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
protected override void OnClassChanged(AbstractNodeClass oldValue, AbstractNodeClass newValue)
{
//Do not forget to call super to set DATA.
base.OnClassChanged(oldValue, newValue);
if (newValue != null && oldValue != newValue)
{
//First update the Input nodes as Size:
this.inputNodes = new Node[newValue.InputTypes.Count()];
CombinedNodeClass ownClass = newValue as CombinedNodeClass;
if (ownClass != null)
{
//This means we are called from the Constructor of the Node class. We get a call with our data later on!
if (ownClass.Connections == null || ownClass.SubElements == null)
{
return;
}
ClassManager classManager = Singleton <ClassManager> .Instance;
this.includedNodes = new Node[ownClass.SubElements.Count];
this.inputConnections = new Dictionary <int, Tuple <Node, int> >();
int i = 0;
//Generate the Nodes:
foreach (SimpleSubNode simpleNode in ownClass.SubElements)
{
Node subNode = simpleNode.GetAsRealNode(classManager);
if (subNode == null)
{
//We have some types that are not registered?!?
throw new Exception("Could not load Node: " + simpleNode.Type);
}
//We have our output node:
if (subNode != null && subNode.NodeUUID == ownClass.OutputNodeUuid)
{
this.outputNode = subNode;
}
this.includedNodes[i] = subNode;
i++;
}
//Generate the Connections:
foreach (SimpleConnection connection in ownClass.Connections)
{
string first = connection.FirstNode;
string second = connection.SecondNode;
int index = connection.Position;
//Search for the 2 nodes:
Node firstNode = this.includedNodes.FirstOrDefault(n => n.NodeUUID == first);
Node secondNode = this.includedNodes.FirstOrDefault(n => n.NodeUUID == second);
//We have an Input node:
if (second.StartsWith("input"))
{
this.inputConnections.Add(Int32.Parse(second.Substring("input".Count())), new Tuple <Node, int>(firstNode, index));
continue;
}
//We have an internal connection:
if (secondNode != null && firstNode != null)
{
Transformation transformation = firstNode as Transformation;
CombinedNode combined = firstNode as CombinedNode;
//We connect a Transformation:
if (transformation != null)
{
transformation.SetInput(index, secondNode);
continue;
}
//We connect a CombinedNode:
if (combined != null)
{
combined.SetInput(index, secondNode);
continue;
}
}
}
//Now we apply the Node-IO-Options:
for (i = 0; i < inputConnections.Count(); i++)
{
Tuple <Node, int> tuple = inputConnections[i];
this.inputIOData[i] = tuple.Item1.InputIOData[tuple.Item2];
}
//After building from base -> We unify the UUIDs, so they are now unique again!
includedNodes.ForEach(n => n.ForceUUID(Guid.NewGuid().ToString()));
}
}
}
public CombinedNode(CombinedNodeClass nodeClass)
{
this.Name = nodeClass.DisplayName;
this.Class = nodeClass;
}
