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