/// <summary> /// Called when the user has started to drag out a connector, thus creating a new connection. /// </summary> public ExecutionConnectionViewModel ExecutionConnectionDragStarted(ExecutionConnectorViewModel draggedOutConnector, Point curDragPoint) { // // Create a new connection to add to the view-model. // var connection = new ExecutionConnectionViewModel(); if (draggedOutConnector.Type == ConnectorType.Output) { // // The user is dragging out a source connector (an output) and will connect it to a destination connector (an input). // connection.SourceConnector = draggedOutConnector; connection.DestConnectorHotspot = curDragPoint; } else { // // The user is dragging out a destination connector (an input) and will connect it to a source connector (an output). // connection.DestConnector = draggedOutConnector; connection.SourceConnectorHotspot = curDragPoint; } // // Add the new connection to the view-model. // this.Network.ExecutionConnections.Add(connection); return(connection); }
/// <summary> /// Called when the user has finished dragging out the new connection. /// </summary> public void ExecutionConnectionDragCompleted(ExecutionConnectionViewModel newConnection, ExecutionConnectorViewModel connectorDraggedOut, ExecutionConnectorViewModel connectorDraggedOver) { if (connectorDraggedOver == null) { // // The connection was unsuccessful. // Maybe the user dragged it out and dropped it in empty space. // this.Network.ExecutionConnections.Remove(newConnection); return; } // // Only allow connections from output connector to input connector (ie each // connector must have a different type). // Also only allocation from one node to another, never one node back to the same node. // bool connectionOk = connectorDraggedOut.ParentNode != connectorDraggedOver.ParentNode && connectorDraggedOut.Type != connectorDraggedOver.Type; if (!connectionOk) { // // Connections between connectors that have the same type, // eg input -> input or output -> output, are not allowed, // Remove the connection. // this.Network.ExecutionConnections.Remove(newConnection); return; } // // The user has dragged the connection on top of another valid connector. // // // Remove any existing connection between the same two connectors. // var existingConnection = FindExecutionConnection(connectorDraggedOut, connectorDraggedOver); if (existingConnection != null) { this.Network.ExecutionConnections.Remove(existingConnection); } // // Finalize the connection by attaching it to the connector // that the user dragged the mouse over. // if (newConnection.DestConnector == null) { newConnection.DestConnector = connectorDraggedOver; } else { newConnection.SourceConnector = connectorDraggedOver; } }
/// <summary> /// Called as the user continues to drag the connection. /// </summary> public void ExecutionConnectionDragging(Point curDragPoint, ExecutionConnectionViewModel connection) { if (connection.DestConnector == null) { connection.DestConnectorHotspot = curDragPoint; } else { connection.SourceConnectorHotspot = curDragPoint; } }
/// <summary> /// Create a node and add it to the view-model. /// </summary> /*public NodeViewModel CreateNode(string name, Point nodeLocation, bool centerNode) * { * var node = new NodeViewModel(name); * node.X = nodeLocation.X; * node.Y = nodeLocation.Y; * * node.InputConnectors.Add(new ConnectorViewModel("In1")); * node.InputConnectors.Add(new ConnectorViewModel("In2")); * node.OutputConnectors.Add(new ConnectorViewModel("Out1")); * node.OutputConnectors.Add(new ConnectorViewModel("Out2")); * * 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 node to the view-model. * // * this.Network.Nodes.Add(node); * * return node; * }*/ /// <summary> /// Utility method to delete a connection from the view-model. /// </summary> public void DeleteExecutionConnection(ExecutionConnectionViewModel connection) { this.Network.ExecutionConnections.Remove(connection); }