private static void DeleteNode(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
if (inputInfo.editorState.focusedNode != null)
{
inputInfo.editorState.focusedNode.Delete();
inputInfo.inputEvent.Use();
}
}
private static void DuplicateNode(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
//if (state.focusedNode != null)
{
// Create new node of same type
DuplicateNodeOrNodes(inputInfo);
inputInfo.inputEvent.Use();
}
}
private static void RemoveConnecition(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (state.focusedConnectionKnob != null)
{
state.focusedNode.DeleteConnectionPort(state.focusedConnectionKnob);
}
}
private static void DuplicateNode(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (state.focusedNode != null)
{ // Create new node of same type
Node duplicatedNode = Node.Create(state.focusedNode.GetID, NodeEditor.ScreenToCanvasSpace(inputInfo.inputPos), state.connectOutput);
state.selectedNode = state.focusedNode = duplicatedNode;
state.connectOutput = null;
inputInfo.inputEvent.Use();
}
}
private static void DeleteNodeKey(NodeEditorInputInfo inputInfo)
{
if (GUIUtility.keyboardControl > 0)
{
return;
}
if (inputInfo.editorState.focusedNode != null)
{
inputInfo.SetAsCurrentEnvironment();
inputInfo.editorState.focusedNode.Delete();
inputInfo.inputEvent.Use();
}
}
private static void DuplicateNode(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (state.focusedNode != null && NodeEditor.curNodeCanvas.CanAddNode(state.focusedNode.GetID))
{ // Create new node of same type
Node duplicatedNode = Node.CreateCopy(state.focusedNode, NodeEditor.ScreenToCanvasSpace(inputInfo.inputPos), state.connectKnob, false);
state.selectedNode = state.focusedNode = duplicatedNode;
state.connectKnob = null;
inputInfo.inputEvent.Use();
}
}
private static void DuplicateNode(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState editorState = inputInfo.editorState;
if ((UnityEngine.Object)editorState.focusedNode != (UnityEngine.Object)null)
{
Node focusedNode = Node.Create(editorState.focusedNode.GetID, NodeEditor.ScreenToCanvasSpace(inputInfo.inputPos), editorState.connectOutput);
editorState.selectedNode = (editorState.focusedNode = focusedNode);
editorState.connectOutput = null;
inputInfo.inputEvent.Use();
}
}
private static void CreateNodeCallback(object infoObj)
{
NodeEditorInputInfo nodeEditorInputInfo = infoObj as NodeEditorInputInfo;
if (nodeEditorInputInfo == null)
{
throw new UnityException("Callback Object passed by context is not of type NodeEditorInputInfo!");
}
nodeEditorInputInfo.SetAsCurrentEnvironment();
Node.Create(nodeEditorInputInfo.message, NodeEditor.ScreenToCanvasSpace(nodeEditorInputInfo.inputPos), nodeEditorInputInfo.editorState.connectOutput);
nodeEditorInputInfo.editorState.connectOutput = null;
NodeEditor.RepaintClients();
}
private static void AddOutConnection(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (state.focusedNode != null &&
state.focusedNode.GetType() == typeof(StateNode))
{
StateNode node = state.focusedNode as StateNode;
node.CreateConnectionKnob(node.StateTransOutAttribute);
}
}
private static void SetAsDefault(NodeEditorInputInfo inputInfo)
{
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (state.focusedNode != null &&
state.focusedNode.GetType() == typeof(StateNode))
{
foreach (var node in state.canvas.nodes)
{
if (node is StateNode)
{
(node as StateNode).IsDefaultState = false;
}
}
(state.focusedNode as StateNode).IsDefaultState = true;
}
}
public static void DeleteNodeOrNodes(NodeEditorInputInfo inputInfo)
{
if (inputInfo.editorState.selectedNode == null && NodeEditor.curEditorState.selectedNodes.Count == 0)
{
return;
}
inputInfo.SetAsCurrentEnvironment();
//if (inputInfo.editorState.focusedNode != null)
{
if (inputInfo.editorState.selectedNode != null && !NodeEditor.curEditorState.selectedNodes.Contains(inputInfo.editorState.selectedNode))
{
NodeEditor.curEditorState.selectedNodes.Add(inputInfo.editorState.selectedNode);
}
{
foreach (var n in NodeEditor.curEditorState.selectedNodes)
{
n.Delete();
}
NodeEditor.curEditorState.selectedNodes.Clear();
}
inputInfo.editorState.selectedNode = null;
}
}
public static void DuplicateNodeOrNodes(NodeEditorInputInfo inputInfo)
{
if (inputInfo.editorState.selectedNode == null && NodeEditor.curEditorState.selectedNodes.Count == 0)
{
return;
}
inputInfo.SetAsCurrentEnvironment();
NodeEditorState state = inputInfo.editorState;
if (inputInfo.editorState.selectedNode != null && !NodeEditor.curEditorState.selectedNodes.Contains(inputInfo.editorState.selectedNode))
{
NodeEditor.curEditorState.selectedNodes.Add(inputInfo.editorState.selectedNode);
}
{
// if(m_CacheOff!=null)
// m_CacheOff();
Dictionary <Node, Node> nodeMap = new Dictionary <Node, Node>();
List <Node> newSelected = new List <Node>();
foreach (var n in NodeEditor.curEditorState.selectedNodes)
{
Node duplicated = Node.Create(n.GetID, n.rect.center, null, false); //state.connectOutput);
// Debug.Log("dupe n "+n);
duplicated.CloneFieldsFrom(n);
state.selectedNode = state.focusedNode = duplicated;
newSelected.Add(duplicated);
nodeMap.Add(n, duplicated);
}
//handle connections
foreach (var n in NodeEditor.curEditorState.selectedNodes)
{
for (int index = 0; index < n.Inputs.Count; index++)
{
NodeInput nodeInput = n.Inputs[index];
if (nodeInput.connection != null)
{
Node connectTo = nodeInput.connection.body;
if (nodeMap.ContainsKey(nodeInput.connection.body))
{
connectTo = nodeMap[nodeInput.connection.body];
}
foreach (NodeOutput on in connectTo.Outputs)
{
if (on.name == nodeInput.connection.name)
{
if (index < nodeMap[n].Inputs.Count)
{
nodeMap[n].Inputs[index].ApplyConnection(on);
}
break;
}
}
}
}
for (int index = 0; index < n.Outputs.Count; index++)
{
NodeOutput nodeOutput = n.Outputs[index];
for (int index1 = 0; index1 < nodeOutput.connections.Count; index1++)
{
NodeInput nodeInput = nodeOutput.connections[index1];
if (nodeInput == null)
{
continue;
}
Node connectTo = nodeInput.body;
if (nodeMap.ContainsKey(connectTo))
{
continue; //we did it allready
}
for (int i = 0; i < connectTo.Inputs.Count; i++)
{
NodeInput inputnode = connectTo.Inputs[i];
if (inputnode.name == nodeInput.name)
{
inputnode.ApplyConnection(nodeOutput);
break;
}
}
}
}
}
NodeEditor.curEditorState.selectedNodes.Clear();
NodeEditor.curEditorState.selectedNodes = newSelected;
NodeEditor.curEditorState.selectedNode = newSelected[0];
// foreach (var x in newSelected)
// Debug.Log(" selected node "+x);
// if (m_CacheOn != null)
// m_CacheOn();
NodeEditorCallbacks.IssueOnAddNode(NodeEditor.curEditorState.selectedNode); //just do it on one node, so it saves the canvas/repaints
}
state.connectOutput = null;
if (m_FinishedDupe != null)
{
m_FinishedDupe();
}
}
private static void CreateGroup(NodeEditorInputInfo info)
{
info.SetAsCurrentEnvironment();
new NodeGroup("Group", NodeEditor.ScreenToCanvasSpace(info.inputPos));
}
