//Following The Test Code #region Private Methods /// <summary> /// A function to conveniently populate the view-model with test data. /// </summary> private void PopulateWithTestData() { // // Create a network, the root of the view-model. // this.Network = new NetworkViewModel(); // // Create some nodes and add them to the view-model. // AbstractNodeViewModel testInXamlEditor = CreateNode <PrintStringNodeViewModel>(new Point(350, 280), false); AbstractNodeViewModel node1 = CreateNode <ConstantIntegerNodeViewModel>(new Point(100, 60), false); AbstractNodeViewModel node2 = CreateNode <ConstantIntegerNodeViewModel>(new Point(100, 90), false); AbstractNodeViewModel node3 = CreateNode <AddIntegerNodeViewModel>(new Point(350, 80), false); AbstractNodeViewModel node4 = CreateNode <ConstantFloatNodeViewModel>(new Point(100, 150), false); AbstractNodeViewModel node5 = CreateNode <ConstantFloatNodeViewModel>(new Point(100, 190), false); AbstractNodeViewModel node6 = CreateNode <AddFloatNodeViewModel>(new Point(350, 120), false); // // Create a connection between the nodes. // ConnectionViewModel connection = new ConnectionViewModel(); connection.SourceConnector = node1.OutputConnectors[0]; connection.DestConnector = node3.InputConnectors[0]; // // Add the connection to the view-model. // this.Network.Connections.Add(connection); }
/// <summary> /// Delete the node from the view-model. /// Also deletes any connections to or from the node. /// </summary> public void DeleteNode(AbstractNodeViewModel node) { // // Remove all connections attached to the node. // this.Network.Connections.RemoveRange(node.AttachedConnections); // // Remove the node from the network. // this.Network.Nodes.Remove(node); }
/// <summary> /// Determine the area covered by the specified list of nodes. /// </summary> private Rect DetermineAreaOfNodes(IList nodes) { AbstractNodeViewModel firstNode = (AbstractNodeViewModel)nodes[0]; Rect actualContentRect = new Rect(firstNode.X, firstNode.Y, firstNode.Size.Width, firstNode.Size.Height); for (int i = 1; i < nodes.Count; ++i) { AbstractNodeViewModel node = (AbstractNodeViewModel)nodes[i]; Rect nodeRect = new Rect(node.X, node.Y, node.Size.Width, node.Size.Height); actualContentRect = Rect.Union(actualContentRect, nodeRect); } return(actualContentRect); }
public void DetectEndOfNode(AbstractNodeViewModel node) { /// Check OutputConnectors Count foreach (var output in node.OutputConnectors) { if (output.AttachedConnections.Count != 0) { return; /// not end } } if (EndOfNodes.IndexOf(node) < 0) { EndOfNodes.Add(node); } }
/// <summary> /// Recursive Solve single node calculation /// </summary> /// <param name="node"></param> /// <returns>Is success solved</returns> private bool UnitSolve(AbstractNodeViewModel node, ConnectorViewModel invokerConnector = null) { { bool isSuccessed = true; if (node.InputConnectors.Count != 0) { foreach (var connector in node.InputConnectors) { // Exist input connectors, so check whether this attached to any node if (connector.AttachedConnections.Count != 0) { // Attached input // Attached num check if (connector.AttachedConnections.Count > 1) { // Usually not reached point throw new NotImplementedException("now input connection must has single attached."); } //So call the self recursively in terms of get this node's destination of the node foreach (var connection in connector.AttachedConnections) { AbstractNodeViewModel outputNode = null; if (connection.DestConnector.Type == ConnectorType.Output) { outputNode = connection.DestConnector.ParentNode; } else { outputNode = connection.SourceConnector.ParentNode; } isSuccessed = UnitSolve(outputNode, connector); } } } } /// If could not solved of just before node, cancel solve //if (!isSuccessed) return false; } /// Execute Calculation node.Calculate(); /// Check node is be able to solve of static //if(node.SolverType != NodeCalculationType.Dynamic) //{ // return false; //} /// Propagate data to invoker foreach (var connector in node.OutputConnectors) { foreach (var connection in connector.AttachedConnections) { ConnectorViewModel outputConnector = null; ConnectorViewModel inputConnector = null; if (connection.DestConnector.Type == ConnectorType.Output) { outputConnector = connection.DestConnector; inputConnector = connection.SourceConnector; } else { outputConnector = connection.SourceConnector; inputConnector = connection.DestConnector; } if (inputConnector == invokerConnector && connection.DestConnector.DataType == invokerConnector.DataType) { invokerConnector.NoRaiseEntity = outputConnector.Entity; } } } return(true); }
/// <summary> /// Create a node and add it to the view-model. /// </summary> public AbstractNodeViewModel CreateNode <NodeType>(Point nodeLocation, bool centerNode) where NodeType : AbstractNodeViewModel { Type Type = typeof(NodeType); AbstractNodeViewModel node = null; try { node = (AbstractNodeViewModel)Activator.CreateInstance(Type); } catch (Exception e) { MessageBox.Show(e.Message); return(node); } node.X = nodeLocation.X; node.Y = nodeLocation.Y; //node.InputConnectors.Add(new ConnectorViewModel("In1",typeof(int))); //node.InputConnectors.Add(new ConnectorViewModel("In2", typeof(int))); //node.OutputConnectors.Add(new ConnectorViewModel("Out1", typeof(int))); //node.OutputConnectors.Add(new ConnectorViewModel("Out2", typeof(int))); //node.OutputConnectors.Add(new ConnectorViewModel("Out1", typeof(int))); //node.OutputConnectors.Add(new ConnectorViewModel("Out2", typeof(int))); if (centerNode) { // // We want to center the node. // // For this to happen we need to wait until the UI has determined the // size based on the node's data-template. // // So we define an anonymous method to handle the SizeChanged event for a node. // // Note: If you don't declare sizeChangedEventHandler before initializing it you will get // an error when you try and unsubscribe the event from within the event handler. // EventHandler <EventArgs> sizeChangedEventHandler = null; sizeChangedEventHandler = delegate(object sender, EventArgs e) { // // This event handler will be called after the size of the node has been determined. // So we can now use the size of the node to modify its position. // node.X -= node.Size.Width / 2; node.Y -= node.Size.Height / 2; // // Don't forget to unhook the event, after the initial centering of the node // we don't need to be notified again of any size changes. // node.SizeChanged -= sizeChangedEventHandler; }; // // Now we hook the SizeChanged event so the anonymous method is called later // when the size of the node has actually been determined. // node.SizeChanged += sizeChangedEventHandler; } // // Add the event of update entity // foreach (var connector in node.InputConnectors) { connector.PropertyChanged += Node_EntityChanged; } foreach (var connector in node.OutputConnectors) { connector.PropertyChanged += Node_EntityChanged; } // // Add the node to the view-model. // this.Network.Nodes.Add(node); return(node); }
private void DecideLastedNode(AbstractNodeViewModel node) { }