public void RemoveVariable(NodeGraphVariable graphVariable)
{
NodeEditor.Assertions.IsTrue(Variables.Contains(graphVariable));
NodeEditor.Logger.Log <NodeGraph>("Removing variable '{0}'", graphVariable.Name);
Variables.Remove(graphVariable);
VariableRemoved.InvokeSafe(graphVariable);
graphVariable.Remove();
Edited.InvokeSafe(this);
}
public void Disconnect(NodeConnection connection)
{
bool containsConnection = Connections.Contains(connection);
NodeEditor.Assertions.IsTrue(containsConnection);
if (containsConnection)
{
Connections.Remove(connection);
NodeEditor.Logger.Log <NodeGraph>("Disconnected {0} from {1}.", connection.SourcePin.Node.Name, connection.TargetPin.Node.Name);
Edited.InvokeSafe(this);
}
}
public void Connect(NodeConnection connection)
{
bool hasConnection = Connections.Contains(connection);
NodeEditor.Assertions.IsFalse(hasConnection);
NodeEditor.Assertions.WarnIsNotNull(connection.SourcePin, "Attempted to connect two pins where the start pin was null.");
NodeEditor.Assertions.WarnIsNotNull(connection.TargetPin, "Attempted to connect two pins where the end pin was null.");
NodeEditor.Assertions.WarnIsFalse(connection.SourcePin == connection.TargetPin, "Attempted to connect a pin to itself.");
//Assert.IsFalse(connection.StartPin.WillPinConnectionCreateCircularDependency(connection.EndPin), "Pin connection would create a circular dependency!");
var canConnect = connection.SourcePin != null &&
connection.TargetPin != null &&
connection.SourcePin != connection.TargetPin;
if (canConnect)
{
var existingConnectionOnStartPin = Helper.GetConnections(connection.SourcePin);
var existingConnectionOnEndPin = Helper.GetConnections(connection.TargetPin);
if (connection.Type == NodeConnectionType.Execute)
{
// Only one connection is allowed between any two execute pins.
existingConnectionOnStartPin.ForEach(x => Connections.Remove(x));
existingConnectionOnEndPin.ForEach(x => Connections.Remove(x));
}
else if (connection.Type == NodeConnectionType.Value)
{
// Input pins on value types can never have multiple connections. Remove existing connections.
existingConnectionOnEndPin.ForEach(x => Connections.Remove(x));
}
var startPinId = connection.SourcePin.Index;
var endPinId = connection.TargetPin.Index;
connection.SourcePin.Connect(connection.TargetPin);
connection.TargetPin.Connect(connection.SourcePin);
// Check if the pin has changed after connecting. This will happen for dynamic pin types.
if (connection.SourcePin.Node.Pins[startPinId] != connection.SourcePin || connection.TargetPin.Node.Pins[endPinId] != connection.TargetPin)
{
connection = new NodeConnection(connection.LeftNode.Pins[startPinId], connection.RightNode.Pins[endPinId]);
}
Connections.Add(connection);
NodeEditor.Logger.Log <NodeGraph>("Connected {0}:(1) to {2}:{3}", connection.LeftNode.Name, connection.SourcePin.Name, connection.RightNode.Name, connection.TargetPin.Name);
Edited.InvokeSafe(this);
}
}
NodeGraphVariable AddVariable(NodeGraphVariableData graphVariableData)
{
NodeEditor.Assertions.IsFalse(Variables.Any(x => x.ID == graphVariableData.ID), "Tried to spawn a variable that has the same ID as an existing variable.");
var variable = new NodeGraphVariable(graphVariableData);
variable.NameChangeRequested += Variable_NameChangeRequested;
Variables.Add(variable);
NodeEditor.Logger.Log <NodeGraph>("Added variable '{0}' ({1})", variable.Name, variable.GetType());
VariableAdded.InvokeSafe(variable);
Edited.InvokeSafe(this);
return(variable);
}
void RegisterNode(Node node)
{
NodeEditor.Assertions.IsFalse(Nodes.Contains(node), "Node already exists in this graph.");
if (!Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Registered node.");
node.Destroyed += RemoveNode;
node.Changed += Node_Changed;
node.PinRemoved += Node_PinRemoved;
Nodes.Add(node);
NodeAdded.InvokeSafe(node);
Edited.InvokeSafe(this);
}
}
public void RemoveNode(Node node)
{
NodeEditor.Assertions.IsTrue(Nodes.Contains(node), "Node Graph does not contain node.");
if (Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Removing node.");
Selection = null;
node.Dispose();
Nodes.Remove(node);
NodeRemoved.InvokeSafe(node);
// TODO: Gracefully handle disconnections...
var connections = Connections
.Where(x => x.SourcePin.Node.ID == node.ID || x.TargetPin.Node.ID == node.ID)
.ToList();
connections.ForEach(x => Disconnect(x));
Edited.InvokeSafe(this);
}
}
void Node_PinRemoved(NodePin pin)
{
Disconnect(pin);
Edited.InvokeSafe(this);
}
void Node_Changed(Node node)
{
NodeEditor.Logger.Log <NodeGraph>("Node {0} changed.", node.Name);
Edited.InvokeSafe(this);
}