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