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