static State CreateGroupNode(State previousState, CreateGroupNodeAction action)
{
GroupNodeModel groupNodeModel = ((VSGraphModel)previousState.CurrentGraphModel).CreateNode <GroupNodeModel>(action.Name, action.Position);
groupNodeModel.AddNodes(action.NodeModels);
return(previousState);
}
static State CreateVariableNodes(State previousState, CreateVariableNodesAction action)
{
if (action.VariablesToCreate.Count > 0)
{
if (action.ConnectAfterCreation != null)
{
// Delete previous connections
if (action.EdgeModelsToDelete.Any())
{
((VSGraphModel)previousState.CurrentGraphModel).DeleteEdges(action.EdgeModelsToDelete);
}
}
bool needToGroup = action.GroupModel != null;
List <INodeModel> nodesToGroup = needToGroup ? new List <INodeModel>(action.VariablesToCreate.Count) : null;
foreach (Tuple <IVariableDeclarationModel, Vector2> tuple in action.VariablesToCreate)
{
VSGraphModel vsGraphModel = ((VSGraphModel)previousState.CurrentGraphModel);
IVariableModel newVariable = vsGraphModel.CreateVariableNode(tuple.Item1, tuple.Item2);
if (action.ConnectAfterCreation != null)
{
var newEdge = ((VSGraphModel)previousState.CurrentGraphModel).CreateEdge(action.ConnectAfterCreation, newVariable.OutputPort);
if (action.AutoAlign)
{
vsGraphModel.LastChanges.ModelsToAutoAlign.Add(newEdge);
}
}
if (needToGroup)
{
nodesToGroup.Add(newVariable);
}
}
if (needToGroup)
{
GroupNodeModel.Ungroup(nodesToGroup);
((GroupNodeModel)action.GroupModel).AddNodes(nodesToGroup);
}
}
return(previousState);
}
public void Test_CreateStackedNodesFromSearcherAction(TestingMode mode, GroupingMode groupingMode,
Type expectedNodeType, Type[] expectedStackTypes,
Func <Stencil, StackBaseModel, StackNodeModelSearcherItem> makeItemFunc)
{
bool inGroupTest = groupingMode == GroupingMode.Grouped;
var stack = GraphModel.CreateStack("stack", Vector2.zero);
var item = makeItemFunc(Stencil, stack);
if (inGroupTest)
{
GroupNodeModel group = GraphModel.CreateGroupNode("", Vector2.zero);
group.AddNode(stack);
}
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2: 1));
Assert.That(GetStackCount(), Is.EqualTo(1));
Assert.That(stack.NodeModels.Count, Is.EqualTo(0));
return(new CreateStackedNodeFromSearcherAction(stack, -1, item));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1 + expectedStackTypes.Length + (inGroupTest ? 1: 0)));
Assert.That(GetStackCount(), Is.EqualTo(1 + expectedStackTypes.Length));
Assert.That(stack.NodeModels.Count, Is.EqualTo(1));
var stackedNodes = stack.NodeModels.ToList();
Assert.That(stackedNodes[0].GetType(), Is.EqualTo(expectedNodeType));
int cnt = 1;
foreach (var expectedStackType in expectedStackTypes)
{
var newStack = GetStack(cnt++);
Assert.That(newStack.GetType(), Is.EqualTo(expectedStackType));
// Nodes added to a stack that is in a group are _not_ themselves grouped.
Assert.That(newStack.IsGrouped, Is.EqualTo(false));
Assert.That(newStack.GroupNodeModel, Is.EqualTo(null));
}
}
);
}
public void Test_MoveElementsActionForGroups([Values] TestingMode mode)
{
var origPosition = new Rect(0, 0, 200, 200);
var newPosition = new Rect(50, -75, 200, 200);
GroupNodeModel groupNode = GraphModel.CreateGroupNode("Group0", origPosition.position);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(groupNode.Position, Is.EqualTo(origPosition.position));
return(new MoveElementsAction(newPosition.position - origPosition.position, null, new [] { groupNode }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(groupNode.Position, Is.EqualTo(newPosition.position));
});
}
public void Test_MoveElementsActionForMultipleTypes([Values] TestingMode mode)
{
var deltaMove = new Vector2(50, -75);
var itemSize = new Vector2(100, 100);
var origNodePosition = Vector2.zero;
var newNodePosition = deltaMove;
var node = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var origGroupPosition = new Rect(Vector2.one * 200, itemSize);
var newGroupPosition = new Rect(origGroupPosition.position + deltaMove, itemSize);
GroupNodeModel groupNode = GraphModel.CreateGroupNode("Group0", origGroupPosition.position);
var origStickyPosition = new Rect(Vector2.one * -100, itemSize);
var newStickyPosition = new Rect(origStickyPosition.position + deltaMove, itemSize);
var stickyNote = (StickyNoteModel)GraphModel.CreateStickyNote("StickyNote0", origStickyPosition);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(origNodePosition));
Assert.That(groupNode.Position, Is.EqualTo(origGroupPosition.position));
Assert.That(GetStickyNote(0).Position, Is.EqualTo(origStickyPosition));
return(new MoveElementsAction(deltaMove, new [] { node }, new [] { groupNode }, new [] { stickyNote }));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(newNodePosition));
Assert.That(groupNode.Position, Is.EqualTo(newGroupPosition.position));
Assert.That(GetStickyNote(0).Position.position, Is.EqualTo(newStickyPosition.position));
});
}
static void CreateItemizedNode(State state, VSGraphModel graphModel, IPortModel inputPortModel, ref IPortModel outputPortModel)
{
bool wasItemized = false;
ItemizeOptions currentItemizeOptions = state.Preferences.CurrentItemizeOptions;
INodeModel nodeToConnect = null;
// automatically itemize, i.e. duplicate variables as they get connected
if (outputPortModel.Connected && currentItemizeOptions != ItemizeOptions.Nothing)
{
nodeToConnect = outputPortModel.NodeModel;
var offset = Vector2.up * k_NodeOffset;
if (currentItemizeOptions.HasFlag(ItemizeOptions.Constants) &&
nodeToConnect is ConstantNodeModel constantModel)
{
string newName = string.IsNullOrEmpty(constantModel.Title)
? "Temporary"
: constantModel.Title + "Copy";
nodeToConnect = graphModel.CreateConstantNode(
newName,
constantModel.Type.GenerateTypeHandle(graphModel.Stencil),
constantModel.Position + offset
);
((ConstantNodeModel)nodeToConnect).ObjectValue = constantModel.ObjectValue;
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.Variables) &&
nodeToConnect is VariableNodeModel variableModel)
{
nodeToConnect = graphModel.CreateVariableNode(variableModel.DeclarationModel,
variableModel.Position + offset);
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.Variables) &&
nodeToConnect is ThisNodeModel thisModel)
{
nodeToConnect = graphModel.CreateNode <ThisNodeModel>("this", thisModel.Position + offset);
}
else if (currentItemizeOptions.HasFlag(ItemizeOptions.SystemConstants) &&
nodeToConnect is SystemConstantNodeModel sysConstModel)
{
Action <SystemConstantNodeModel> preDefineSetup = m =>
{
m.ReturnType = sysConstModel.ReturnType;
m.DeclaringType = sysConstModel.DeclaringType;
m.Identifier = sysConstModel.Identifier;
};
nodeToConnect = graphModel.CreateNode(sysConstModel.Title, sysConstModel.Position + offset, SpawnFlags.Default, preDefineSetup);
}
wasItemized = nodeToConnect != outputPortModel.NodeModel;
outputPortModel = nodeToConnect.OutputsById[outputPortModel.UniqueId];
}
GroupNodeModel groupNodeModel = null;
if (wasItemized)
{
if (inputPortModel.NodeModel.IsGrouped)
{
groupNodeModel = (GroupNodeModel)inputPortModel.NodeModel.GroupNodeModel;
}
else if (inputPortModel.NodeModel.IsStacked && inputPortModel.NodeModel.ParentStackModel.IsGrouped)
{
groupNodeModel = (GroupNodeModel)inputPortModel.NodeModel.ParentStackModel.GroupNodeModel;
}
}
if (groupNodeModel != null)
{
groupNodeModel.AddNode(nodeToConnect);
}
}
public void Test_CreateEdgeAction_Itemize(TestingMode testingMode, GroupingMode groupingMode, ItemizeOptions options, ItemizeTestType itemizeTest, Func <VSGraphModel, IHasMainOutputPort> makeNode)
{
// save initial itemize options
VSPreferences pref = ((TestState)m_Store.GetState()).Preferences;
ItemizeOptions initialOptions = pref.CurrentItemizeOptions;
bool inGroupTest = groupingMode == GroupingMode.Grouped;
try
{
// create int node
IHasMainOutputPort node0 = makeNode(GraphModel);
IPortModel output0 = node0.OutputPort;
// create Addition node
BinaryOperatorNodeModel opNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GroupNodeModel group = null;
if (inGroupTest)
{
// Create GroupNode
group = GraphModel.CreateGroupNode("", Vector2.zero);
group.AddNode(opNode);
}
// enable Itemize depending on the test case
var itemizeOptions = ItemizeOptions.Nothing;
pref.CurrentItemizeOptions = (itemizeTest == ItemizeTestType.Enabled) ? options : itemizeOptions;
// connect int to first input
m_Store.Dispatch(new CreateEdgeAction(opNode.InputPortA, output0));
m_Store.Update();
// test how the node reacts to getting connected a second time
TestPrereqActionPostreq(testingMode,
() =>
{
var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First();
IPortModel input0 = binOp.InputPortA;
IPortModel input1 = binOp.InputPortB;
IPortModel binOutput = binOp.OutputPort;
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(input0, Is.ConnectedTo(output0));
Assert.That(input1, Is.Not.ConnectedTo(output0));
Assert.That(binOutput.Connected, Is.False);
Assert.False(node0.IsGrouped);
Assert.That(node0.GroupNodeModel, Is.EqualTo(null));
return(new CreateEdgeAction(input1, output0));
},
() =>
{
var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First();
IPortModel input0 = binOp.InputPortA;
IPortModel input1 = binOp.InputPortB;
IPortModel binOutput = binOp.OutputPort;
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(input0, Is.ConnectedTo(output0));
Assert.That(binOutput.Connected, Is.False);
Assert.False(node0.IsGrouped);
Assert.That(node0.GroupNodeModel, Is.EqualTo(null));
if (itemizeTest == ItemizeTestType.Enabled)
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 4 : 3));
IHasMainOutputPort newNode = GetNode(inGroupTest ? 3 : 2) as IHasMainOutputPort;
Assert.That(newNode, Is.Not.Null);
Assert.That(newNode, Is.TypeOf(node0.GetType()));
// ReSharper disable once PossibleNullReferenceException
Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newNode.GroupNodeModel, Is.EqualTo(group));
IPortModel output1 = newNode.OutputPort;
Assert.That(input1, Is.ConnectedTo(output1));
}
else
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3: 2));
}
});
}
finally
{
// restore itemize options
pref.CurrentItemizeOptions = initialOptions;
}
}
public static GraphElement CreateNode(this INodeBuilder builder, Store store, GroupNodeModel model)
{
return(new Group(model, store, builder.GraphView));
}
