Example #1
0
        internal void Delete(object parameters)
        {
            if (null != parameters) // See above for details of this exception.
            {
                var message = "Internal error, argument must be null";
                throw new ArgumentException(message, "parameters");
            }

            var command = new DynamoModel.DeleteModelCommand(Guid.Empty);
            this.ExecuteCommand(command);
        }
Example #2
0
 internal void UngroupAnnotation(object parameters)
 {
     if (null != parameters)
     {
         var message = "Internal error, argument must be null";
         throw new ArgumentException(message, "parameters");
     }
     //Check for multiple groups - Delete the group and not the nodes.
     foreach (var group in DynamoSelection.Instance.Selection.OfType<AnnotationModel>().ToList())
     {
         var command = new DynamoModel.DeleteModelCommand(group.GUID);
         this.ExecuteCommand(command);
     }            
 }
Example #3
0
 private void DeleteNodeAndItsConnectors(object parameter)
 {
     var command = new DynamoModel.DeleteModelCommand(nodeLogic.GUID);
     DynamoViewModel.ExecuteCommand(command);
 }
Example #4
0
        public void ModificationUITesting()
        {
            // Re-use code for creating a custom node
            CanCreateAndPlaceNewCustomNode();

            var instance = CurrentDynamoModel.CurrentWorkspace.Nodes.First() as Function;
            SelectTabByGuid(instance.Definition.FunctionId);

            var currentInPortAmt = 0;
            var currentOutPortAmt = 0;

            #region Adding
            Func<string, Symbol> addInput = label =>
            {
                var node = new Symbol();
                CurrentDynamoModel.ExecuteCommand(new DynamoModel.CreateNodeCommand(node, 0, 0, true, true));
                node.InputSymbol = label;

                Assert.AreEqual(++currentInPortAmt, instance.InPorts.Count);
                Assert.AreEqual(label, instance.InPorts.Last().PortName);

                return node;
            };

            Func<string, Output> addOutput = label =>
            {
                var node = new Output();

                CurrentDynamoModel.ExecuteCommand(new DynamoModel.CreateNodeCommand(node, 0, 0, true, true));
                node.Symbol = label;

                Assert.AreEqual(++currentOutPortAmt, instance.OutPorts.Count);
                Assert.AreEqual(label, instance.OutPorts.Last().PortName);

                return node;
            };
            #endregion

            #region Renaming
            Action<Symbol, int, string> renameInput = (input, idx, s) =>
            {
                input.InputSymbol = s;
                Assert.AreEqual(s, instance.InPorts[idx].PortName);
            };

            Action<Output, int, string> renameOutput = (output, idx, s) =>
            {
                output.Symbol = s;
                Assert.AreEqual(s, instance.OutPorts[idx].PortName);
            };
            #endregion

            #region Deleting
            Action<NodeModel> deleteNode = nodeModel =>
            {
                DynamoSelection.Instance.ClearSelection();
                CurrentDynamoModel.AddToSelection(nodeModel);
                var command = new DynamoModel.DeleteModelCommand(Guid.Empty);
                CurrentDynamoModel.ExecuteCommand(command);
            };

            Action<Symbol> deleteInput = input =>
            {
                deleteNode(input);
                Assert.AreEqual(--currentInPortAmt, instance.InPorts.Count);
            };

            Action<Output> deleteOutput = output =>
            {
                deleteNode(output);
                Assert.AreEqual(--currentOutPortAmt, instance.OutPorts.Count);
            };
            #endregion

            //Add some outputs
            var out1 = addOutput("output1");
            var out2 = addOutput("output2");

            //Add some inputs
            var in1 = addInput("input1");
            var in2 = addInput("input2");

            //Change some names
            renameInput(in1, 0, "test");
            renameOutput(out2, 1, "something");

            //Delete some ports
            deleteInput(in2);
            deleteOutput(out1);
        }
Example #5
0
        public override int Mutate(NodeModel node)
        {
            DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
            {
                DynamoModel.DeleteModelCommand delCommand =
                    new DynamoModel.DeleteModelCommand(node.GUID);

                DynamoViewModel.ExecuteCommand(delCommand);

            }));

            return 1;
        }
        public void MAGN9434_DeleteCodeBlockNode()
        {
            OpenVisualizationTest("CreatePoint.dyn");
            Assert.AreEqual(1, BackgroundPreviewGeometry.TotalPoints());
            var codeBlockNode = ViewModel.CurrentSpace.NodeFromWorkspace<CodeBlockNodeModel>(Guid.Parse("7883d92a-ef8b-4e05-8c7d-46cfc627c994"));

            var command = new DynamoModel.UpdateModelValueCommand(Guid.Empty, codeBlockNode.GUID, "Code", "p2 = Point.ByCoordinates();");
            ViewModel.Model.ExecuteCommand(command);
            Assert.AreEqual(1, BackgroundPreviewGeometry.TotalPoints());

            var deleteCommand = new DynamoModel.DeleteModelCommand(codeBlockNode.GUID);
            ViewModel.Model.ExecuteCommand(deleteCommand);
            Assert.AreEqual(0, BackgroundPreviewGeometry.TotalPoints());
        }
Example #7
0
        public override int Mutate(NodeModel node)
        {
            this.DynamoViewModel.UIDispatcher.Invoke(new Action(() =>
                {
                    DynamoModel.DeleteModelCommand delCommand =
                        new DynamoModel.DeleteModelCommand(node.GUID);
                
                    DynamoViewModel.ExecuteCommand(delCommand);
                }));

            //We've performed a single delete
            return 1;
        }