private void Connect(PortModel p)
{
//test if the port that you are connecting too is not the start port or the end port
//of the current connector
if (p.Equals(Start) || p.Equals(End))
{
return;
}
//if the selected connector is also an output connector, return false
//output ports can't be connected to eachother
if (p.PortType == PortType.Output)
{
return;
}
//test if the port that you are connecting to is an input and
//already has other connectors
if (p.PortType == PortType.Input && p.Connectors.Count > 0)
{
p.Disconnect(p.Connectors[0]);
}
//turn the line solid
End = p;
if (End != null)
{
p.Connect(this);
}
return;
}
public PortViewModel(PortModel port, NodeModel node)
{
_node = node;
_port = port;
_port.PropertyChanged += _port_PropertyChanged;
_node.PropertyChanged += _node_PropertyChanged;
}
private ConnectorModel(WorkspaceModel workspaceModel, NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
{
this.workspaceModel = workspaceModel;
pStart = start.OutPorts[startIndex];
PortModel endPort = null;
if (portType == PortType.INPUT)
endPort = end.InPorts[endIndex];
pStart.Connect(this);
this.Connect(endPort);
}
private ConnectorModel(NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
{
//Stopwatch sw = new Stopwatch();
//sw.Start();
pStart = start.OutPorts[startIndex];
PortModel endPort = null;
if (portType == PortType.INPUT)
endPort = end.InPorts[endIndex];
pStart.Connect(this);
this.Connect(endPort);
//sw.Stop();
//Debug.WriteLine(string.Format("{0} elapsed for constructing connector.", sw.Elapsed));
}
/// <summary>
/// Since the ports can have a margin (offset) so that they can moved vertically from its
/// initial position, the center of the port needs to be calculted differently and not only
/// based on the index. The function adds the height of other nodes as well as their margins
/// </summary>
/// <param name="portModel"> The portModel whose height is to be found</param>
/// <returns> Returns the offset of the given port from the top of the ports </returns>
internal double GetPortVerticalOffset(PortModel portModel)
{
double verticalOffset = 2.9;
PortType portType;
int index = GetPortIndexAndType(portModel, out portType);
//If the port was not found, then it should have just been deleted. Return from function
if (index == -1)
return verticalOffset;
double portHeight = portModel.Height;
if (portType == PortType.INPUT)
{
for (int i = 0; i < index; i++)
verticalOffset += inPorts[i].MarginThickness.Top + portHeight;
verticalOffset += inPorts[index].MarginThickness.Top;
}
else if (portType == PortType.OUTPUT)
{
for (int i = 0; i < index; i++)
verticalOffset += outPorts[i].MarginThickness.Top + portHeight;
verticalOffset += outPorts[index].MarginThickness.Top;
}
return verticalOffset;
}
protected override void PortDisconnectedHandler(PortModel obj)
{
OnClear();
}
protected override void PortConnectedHandler(PortModel arg1, ConnectorModel arg2)
{
UpdateUpstream();
}
/// <summary>
/// Construct a view and start drawing.
/// </summary>
/// <param name="port"></param>
public ConnectorViewModel(PortModel port)
{
IsConnecting = true;
_activeStartPort = port;
Redraw(port.Center);
}
/// <summary>
/// Construct a view and start drawing.
/// </summary>
/// <param name="port"></param>
public ConnectorViewModel(WorkspaceViewModel workspace, PortModel port)
{
this.workspaceViewModel = workspace;
IsConnecting = true;
_activeStartPort = port;
Redraw(port.Center);
}
/// <summary>
/// Add a port to this node. If the port already exists, return that port.
/// </summary>
/// <param name="portType"></param>
/// <param name="data"></param>
/// <param name="index"></param>
/// <returns></returns>
public PortModel AddPort(PortType portType, PortData data, int index)
{
PortModel p;
switch (portType)
{
case PortType.INPUT:
if (inPorts.Count > index)
{
p = inPorts[index];
//update the name on the node
//e.x. when the node is being re-registered during a custom
//node save
p.PortName = data.NickName;
if (data.HasDefaultValue)
{
p.UsingDefaultValue = true;
p.DefaultValueEnabled = true;
}
return p;
}
p = new PortModel(index, portType, this, data.NickName)
{
UsingDefaultValue = data.HasDefaultValue,
DefaultValueEnabled = data.HasDefaultValue
};
p.PropertyChanged += delegate(object sender, PropertyChangedEventArgs args)
{
if (args.PropertyName == "UsingDefaultValue")
RequiresRecalc = true;
};
InPorts.Add(p);
//register listeners on the port
p.PortConnected += p_PortConnected;
p.PortDisconnected += p_PortDisconnected;
return p;
case PortType.OUTPUT:
if (outPorts.Count > index)
{
p = outPorts[index];
p.PortName = data.NickName;
return p;
}
p = new PortModel(index, portType, this, data.NickName)
{
UsingDefaultValue = false
};
OutPorts.Add(p);
//register listeners on the port
p.PortConnected += p_PortConnected;
p.PortDisconnected += p_PortDisconnected;
return p;
}
return null;
}
private void PortDisconnected(PortModel port)
{
ValidateConnections();
if (port.PortType != PortType.Input) return;
var data = InPorts.IndexOf(port);
var startPort = port.Connectors[0].Start;
DisconnectInput(data);
startPort.Owner.DisconnectOutput(startPort.Owner.OutPorts.IndexOf(startPort), data, this);
OnNodeModified();
}
private void PortConnected(PortModel port, ConnectorModel connector)
{
ValidateConnections();
if (port.PortType != PortType.Input) return;
var data = InPorts.IndexOf(port);
var startPort = connector.Start;
var outData = startPort.Owner.OutPorts.IndexOf(startPort);
ConnectInput(data, outData, startPort.Owner);
startPort.Owner.ConnectOutput(outData, data, this);
OnConnectorAdded(connector);
OnNodeModified();
}
/// <summary>
/// Add a port to this node. If the port already exists, return that port.
/// </summary>
/// <param name="portType"></param>
/// <param name="data"></param>
/// <param name="index"></param>
/// <returns></returns>
public PortModel AddPort(PortType portType, PortData data, int index)
{
PortModel p;
switch (portType)
{
case PortType.Input:
if (inPorts.Count > index)
{
p = inPorts[index];
p.SetPortData(data);
}
else
{
p = new PortModel(portType, this, data);
p.PropertyChanged += delegate(object sender, PropertyChangedEventArgs args)
{
if (args.PropertyName == "UsingDefaultValue")
{
OnNodeModified();
}
};
//register listeners on the port
p.PortConnected += PortConnected;
p.PortDisconnected += PortDisconnected;
InPorts.Add(p);
}
return p;
case PortType.Output:
if (outPorts.Count > index)
{
p = outPorts[index];
p.SetPortData(data);
}
else
{
p = new PortModel(portType, this, data);
OutPorts.Add(p);
//register listeners on the port
p.PortConnected += PortConnected;
p.PortDisconnected += PortDisconnected;
}
return p;
}
return null;
}
/// <summary>
/// Since the ports can have a margin (offset) so that they can moved vertically from its
/// initial position, the center of the port needs to be calculted differently and not only
/// based on the index. The function adds the height of other nodes as well as their margins
/// </summary>
/// <param name="portModel"> The portModel whose height is to be found</param>
/// <returns> Returns the offset of the given port from the top of the ports </returns>
//TODO(Steve): This kind of UI calculation should probably live on the VM. -- MAGN-5711
internal double GetPortVerticalOffset(PortModel portModel)
{
double verticalOffset = 2.9;
int index = portModel.Index;
//If the port was not found, then it should have just been deleted. Return from function
if (index == -1)
return verticalOffset;
double portHeight = portModel.Height;
switch (portModel.PortType)
{
case PortType.Input:
for (int i = 0; i < index; i++)
verticalOffset += inPorts[i].MarginThickness.Top + portHeight;
verticalOffset += inPorts[index].MarginThickness.Top;
break;
case PortType.Output:
for (int i = 0; i < index; i++)
verticalOffset += outPorts[i].MarginThickness.Top + portHeight;
verticalOffset += outPorts[index].MarginThickness.Top;
break;
}
return verticalOffset;
}
internal int GetPortModelIndex(PortModel portModel)
{
if (portModel.PortType == PortType.Input)
return InPorts.IndexOf(portModel);
else
return OutPorts.IndexOf(portModel);
}
internal int GetPortIndex(PortModel portModel, out PortType portType)
{
int index = this.inPorts.IndexOf(portModel);
if (-1 != index)
{
portType = PortType.INPUT;
return index;
}
index = this.outPorts.IndexOf(portModel);
if (-1 != index)
{
portType = PortType.OUTPUT;
return index;
}
portType = PortType.INPUT;
return -1; // No port found.
}
void BeginConnection(Guid nodeId, int portIndex, PortType portType)
{
bool isInPort = portType == PortType.Input;
activeStartPort = null;
var node = CurrentWorkspace.GetModelInternal(nodeId) as NodeModel;
if (node == null)
return;
PortModel portModel = isInPort ? node.InPorts[portIndex] : node.OutPorts[portIndex];
// Test if port already has a connection, if so grab it and begin connecting
// to somewhere else (we don't allow the grabbing of the start connector).
if (portModel.Connectors.Count > 0 && portModel.Connectors[0].Start != portModel)
{
activeStartPort = portModel.Connectors[0].Start;
// Disconnect the connector model from its start and end ports
// and remove it from the connectors collection. This will also
// remove the view model.
ConnectorModel connector = portModel.Connectors[0];
if (CurrentWorkspace.Connectors.Contains(connector))
{
var models = new List<ModelBase> { connector };
CurrentWorkspace.RecordAndDeleteModels(models);
connector.Delete();
}
}
else
{
activeStartPort = portModel;
}
}
private void DestroyConnectors(PortModel port)
{
while (port.Connectors.Any())
{
var connector = port.Connectors[0];
WorkSpace.Connectors.Remove(connector);
connector.NotifyConnectedPortsOfDeletion();
}
}
protected virtual void PortConnectedHandler(PortModel arg1, ConnectorModel arg2)
{
// Do nothing for a standard node.
}
void MakeConnectionImpl(MakeConnectionCommand command)
{
Guid nodeId = command.ModelGuid;
switch (command.ConnectionMode)
{
case MakeConnectionCommand.Mode.Begin:
BeginConnection(nodeId, command.PortIndex, command.Type);
break;
case MakeConnectionCommand.Mode.End:
EndConnection(nodeId, command.PortIndex, command.Type);
break;
case MakeConnectionCommand.Mode.Cancel:
activeStartPort = null;
break;
}
}
/// <summary>
/// Registers the port events.
/// </summary>
/// <param name="item">PortModel.</param>
/// <returns></returns>
private PortViewModel SubscribePortEvents(PortModel item)
{
PortViewModel portViewModel = new PortViewModel(this, item);
portViewModel.MouseEnter += OnRectangleMouseEnter;
portViewModel.MouseLeave += OnRectangleMouseLeave;
portViewModel.MouseLeftButtonDown += OnMouseLeftButtonDown;
return portViewModel;
}
void EndConnection(Guid nodeId, int portIndex, PortType portType)
{
bool isInPort = portType == PortType.Input;
var node = CurrentWorkspace.GetModelInternal(nodeId) as NodeModel;
if (node == null)
return;
PortModel portModel = isInPort ? node.InPorts[portIndex] : node.OutPorts[portIndex];
ConnectorModel connectorToRemove = null;
// Remove connector if one already exists
if (portModel.Connectors.Count > 0 && portModel.PortType == PortType.Input)
{
connectorToRemove = portModel.Connectors[0];
connectorToRemove.Delete();
}
// We could either connect from an input port to an output port, or
// another way around (in which case we swap first and second ports).
PortModel firstPort, second;
if (portModel.PortType != PortType.Input)
{
firstPort = portModel;
second = activeStartPort;
}
else
{
// Create the new connector model
firstPort = activeStartPort;
second = portModel;
}
ConnectorModel newConnectorModel = ConnectorModel.Make(
firstPort.Owner,
second.Owner,
firstPort.Index,
second.Index);
// Record the creation of connector in the undo recorder.
var models = new Dictionary<ModelBase, UndoRedoRecorder.UserAction>();
if (connectorToRemove != null)
models.Add(connectorToRemove, UndoRedoRecorder.UserAction.Deletion);
models.Add(newConnectorModel, UndoRedoRecorder.UserAction.Creation);
WorkspaceModel.RecordModelsForUndo(models, CurrentWorkspace.UndoRecorder);
activeStartPort = null;
}
public void Disconnect(PortModel p)
{
if (p.Equals(pStart))
{
pStart = null;
}
if (p.Equals(pEnd))
{
pEnd = null;
}
p.Disconnect(this);
}
protected virtual void PortDisconnectedHandler(PortModel port)
{
DeleteGeometryForIdentifier(port.Owner.AstIdentifierBase);
}
protected override void DeserializeCore(XmlElement element, SaveContext context)
{
XmlElementHelper helper = new XmlElementHelper(element);
// Restore some information from the node attributes.
this.GUID = helper.ReadGuid("guid", this.GUID);
Guid startNodeId = helper.ReadGuid("start");
int startIndex = helper.ReadInteger("start_index");
Guid endNodeId = helper.ReadGuid("end");
int endIndex = helper.ReadInteger("end_index");
PortType portType = ((PortType)helper.ReadInteger("portType"));
// Get to the start and end nodes that this connector connects to.
WorkspaceModel workspace = dynSettings.Controller.DynamoModel.CurrentWorkspace;
NodeModel startNode = workspace.GetModelInternal(startNodeId) as NodeModel;
NodeModel endNode = workspace.GetModelInternal(endNodeId) as NodeModel;
pStart = startNode.OutPorts[startIndex];
PortModel endPort = null;
if (portType == PortType.INPUT)
endPort = endNode.InPorts[endIndex];
pStart.Connect(this);
this.Connect(endPort);
}