public void CleanWorkbenchClearsUndoStack()
{
var dynamoModel = ViewModel.Model;
Assert.IsNotNull(dynamoModel.CurrentWorkspace);
var workspace = dynamoModel.CurrentWorkspace;
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
Assert.AreEqual(0, workspace.Nodes.Count()); // An empty workspace
var addNode = new DSFunction(dynamoModel.LibraryServices.GetFunctionDescriptor("+"));
var createNodeCommand = new DynamoModel.CreateNodeCommand(
addNode, 0, 0, false, false);
// Create a new node in the empty workspace.
ViewModel.ExecuteCommand(createNodeCommand);
Assert.AreEqual(1, workspace.Nodes.Count());
Assert.AreEqual(true, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
dynamoModel.CurrentWorkspace.Clear(); // Clearing current workspace.
// Undo stack should be cleared.
Assert.AreEqual(false, workspace.CanUndo);
Assert.AreEqual(false, workspace.CanRedo);
}
public void CanCreateGroupIfANodeIsAlreadyInAGroup()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the note for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
//Check if the group is created
Assert.IsNotNull(annotation);
//Clear the selection
DynamoSelection.Instance.ClearSelection();
//Select the node again
DynamoSelection.Instance.Selection.Add(addNode);
//Check whether group can be created
Assert.AreEqual(false,ViewModel.CanAddAnnotation(null));
}
public void DescriptionTest()
{
var assembly = System.Reflection.Assembly.UnsafeLoadFrom("FFITarget.dll");
var testClass = assembly.GetType("FFITarget.DummyZeroTouchClass");
MethodInfo methodWithDesc = testClass.GetMethod("FunctionWithDescription");
MethodInfo methodWithoutDesc = testClass.GetMethod("FunctionWithoutDescription");
NodeDescriptionAttribute atr = new NodeDescriptionAttribute("");
IEnumerable<TypedParameter> arguments;
FunctionDescriptor fucDescriptor;
// 1 case. Method with description.
var attributes = methodWithDesc.GetCustomAttributes(typeof(NodeDescriptionAttribute), false);
Assert.IsNotNull(attributes);
Assert.Greater(attributes.Length, 0);
atr = attributes[0] as NodeDescriptionAttribute;
arguments = methodWithDesc.GetParameters().Select(
arg =>
{
var type = new ProtoCore.Type();
type.Name = arg.ParameterType.ToString();
return new TypedParameter(arg.Name, type);
});
fucDescriptor = new FunctionDescriptor(new FunctionDescriptorParams
{
FunctionName = methodWithDesc.Name,
Summary = atr.ElementDescription,
Parameters = arguments
});
NodeModel node = new DSFunction(fucDescriptor);
Assert.AreEqual(atr.ElementDescription + "\n\n" + fucDescriptor.Signature, node.Description);
// 2 case. Method without description.
atr = new NodeDescriptionAttribute("");
attributes = methodWithoutDesc.GetCustomAttributes(typeof(NodeDescriptionAttribute), false);
Assert.IsNotNull(attributes);
Assert.AreEqual(attributes.Length, 0);
arguments = methodWithoutDesc.GetParameters().Select(
arg =>
{
var type = new ProtoCore.Type();
type.Name = arg.ParameterType.ToString();
return new TypedParameter(arg.Name, type);
});
fucDescriptor = new FunctionDescriptor(new FunctionDescriptorParams
{
FunctionName = methodWithDesc.Name,
Summary = atr.ElementDescription,
Parameters = arguments
});
node = new DSFunction(fucDescriptor);
Assert.AreEqual(fucDescriptor.Signature, node.Description);
}
public void Freeze_ANode_Test()
{
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
Assert.AreEqual(addNode.IsFrozen, false);
addNode.IsFrozen = true;
Assert.AreEqual(addNode.IsFrozen, true);
}
public void Node_InFreeze_ExecuteState_Test()
{
var model = ViewModel.Model;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
//Now Freeze the NumberNode1.
numberNode1.IsFrozen = true;
//Get the ViewModel of the number node and check the Freeze property.
var numberNodevm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode1);
Assert.IsNotNull(numberNodevm);
Assert.AreEqual(numberNodevm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNodevm.CanToggleFrozen, true);
//Get the ViewModel of add node and check the Freeze property. This node is a child node of numbernode1.
//so this node should be in Frozen and Executing state.
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
}
public void CanAddOneNodeToClipboard()
{
int numNodes = 1;
// create 100 nodes, and select them as you go
for (int i = 0; i < numNodes; i++)
{
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(i + 1, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
CurrentDynamoModel.AddToSelection(CurrentDynamoModel.CurrentWorkspace.Nodes.Last());
Assert.AreEqual(i + 1, DynamoSelection.Instance.Selection.Count);
}
CurrentDynamoModel.Copy();
Assert.AreEqual(numNodes, CurrentDynamoModel.ClipBoard.Count);
}
public void WorkspaceModelHasCorrectDependencies()
{
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
var ws = this.CurrentDynamoModel.CustomNodeManager.CreateCustomNode("someNode", "someCategory", "");
var csid = (ws as CustomNodeWorkspaceModel).CustomNodeId;
var customNode = this.CurrentDynamoModel.CustomNodeManager.CreateCustomNodeInstance(csid);
Assert.AreEqual(0, CurrentDynamoModel.CurrentWorkspace.Dependencies.ToList().Count());
CurrentDynamoModel.AddNodeToCurrentWorkspace(customNode, false);
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(1, CurrentDynamoModel.CurrentWorkspace.Dependencies.ToList().Count());
//assert that we still only record one dep even though custom node is in graph twice.
CurrentDynamoModel.AddNodeToCurrentWorkspace(customNode, false);
Assert.AreEqual(1, CurrentDynamoModel.CurrentWorkspace.Dependencies.ToList().Count());
//assert that guid we have stored is is the custom nodes functionID
Assert.AreEqual(customNode.FunctionUuid, CurrentDynamoModel.CurrentWorkspace.Dependencies.First());
}
public void TestBasicAttributes()
{
var sumNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"))
{
X = 400, Y = 100
};
//Assert initial values
Assert.AreEqual(400, sumNode.X);
Assert.AreEqual(100, sumNode.Y);
Assert.AreEqual("+", sumNode.Name);
Assert.AreEqual(LacingStrategy.Auto, sumNode.ArgumentLacing);
Assert.AreEqual(true, sumNode.IsVisible);
Assert.AreEqual(ElementState.Dead, sumNode.State);
//Serialize node and then change values
XmlDocument xmlDoc = new XmlDocument();
XmlElement serializedEl = sumNode.Serialize(xmlDoc, SaveContext.Undo);
sumNode.X = 250;
sumNode.Y = 0;
sumNode.Name = "TestNode";
sumNode.UpdateValue(new UpdateValueParams("ArgumentLacing", "CrossProduct"));
sumNode.UpdateValue(new UpdateValueParams("IsVisible", "false"));
sumNode.State = ElementState.Active;
//Assert New Changes
Assert.AreEqual(250, sumNode.X);
Assert.AreEqual(0, sumNode.Y);
Assert.AreEqual("TestNode", sumNode.Name);
Assert.AreEqual(LacingStrategy.CrossProduct, sumNode.ArgumentLacing);
Assert.AreEqual(false, sumNode.IsVisible);
Assert.AreEqual(ElementState.Active, sumNode.State);
//Deserialize and Assert Old values
sumNode.Deserialize(serializedEl, SaveContext.Undo);
Assert.AreEqual(400, sumNode.X);
Assert.AreEqual(100, sumNode.Y);
Assert.AreEqual("+", sumNode.Name);
Assert.AreEqual(LacingStrategy.Auto, sumNode.ArgumentLacing);
Assert.AreEqual(true, sumNode.IsVisible);
Assert.AreEqual(ElementState.Dead, sumNode.State);
}
public void TestBasicAttributes()
{
var sumNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+")) { X = 400, Y = 100 };
//Assert inital values
Assert.AreEqual(400, sumNode.X);
Assert.AreEqual(100, sumNode.Y);
Assert.AreEqual("+", sumNode.NickName);
Assert.AreEqual(LacingStrategy.Auto, sumNode.ArgumentLacing);
Assert.AreEqual(true, sumNode.IsVisible);
Assert.AreEqual(true, sumNode.IsUpstreamVisible);
Assert.AreEqual(ElementState.Dead, sumNode.State);
//Serialize node and then change values
XmlDocument xmlDoc = new XmlDocument();
XmlElement serializedEl = sumNode.Serialize(xmlDoc, SaveContext.Undo);
sumNode.X = 250;
sumNode.Y = 0;
sumNode.NickName = "TestNode";
sumNode.UpdateValue(new UpdateValueParams("ArgumentLacing", "CrossProduct"));
sumNode.UpdateValue(new UpdateValueParams("IsVisible", "false"));
sumNode.UpdateValue(new UpdateValueParams("IsUpstreamVisible", "false"));
sumNode.State = ElementState.Active;
//Assert New Changes
Assert.AreEqual(250, sumNode.X);
Assert.AreEqual(0, sumNode.Y);
Assert.AreEqual("TestNode", sumNode.NickName);
Assert.AreEqual(LacingStrategy.CrossProduct, sumNode.ArgumentLacing);
Assert.AreEqual(false, sumNode.IsVisible);
Assert.AreEqual(false, sumNode.IsUpstreamVisible);
Assert.AreEqual(ElementState.Active, sumNode.State);
//Deserialize and Assert Old values
sumNode.Deserialize(serializedEl, SaveContext.Undo);
Assert.AreEqual(400, sumNode.X);
Assert.AreEqual(100, sumNode.Y);
Assert.AreEqual("+", sumNode.NickName);
Assert.AreEqual(LacingStrategy.Auto, sumNode.ArgumentLacing);
Assert.AreEqual(true, sumNode.IsVisible);
Assert.AreEqual(true, sumNode.IsUpstreamVisible);
Assert.AreEqual(ElementState.Dead, sumNode.State);
}
public void TooglePresetVisibilityWithUndoRedo()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Check the Preset option visibility.
Assert.AreEqual(false, ViewModel.EnablePresetOptions);
DynamoSelection.Instance.Selection.Add(addNode);
var ids = DynamoSelection.Instance.Selection.OfType <NodeModel>().Select(x => x.GUID).ToList();
//create the preset from 2 nodes
ViewModel.Model.ExecuteCommand(new DynamoModel.AddPresetCommand("state1", "a state with 2 numbers", ids));
//assert that the preset has been created
Assert.AreEqual(ViewModel.Model.CurrentWorkspace.Presets.Count(), 1);
Assert.AreEqual(ViewModel.Model.CurrentWorkspace.Presets.First().Nodes.Count(), 1);
//Check the Preset option visibility.
Assert.AreEqual(true, ViewModel.EnablePresetOptions);
//undo the preset creation
ViewModel.CurrentSpace.UndoRecorder.Undo();
Assert.AreEqual(ViewModel.Model.CurrentWorkspace.Presets.Count(), 0);
//Check the Preset option visibility.
Assert.AreEqual(false, ViewModel.EnablePresetOptions);
//redo the preset creation
ViewModel.CurrentSpace.UndoRecorder.Redo();
Assert.AreEqual(ViewModel.Model.CurrentWorkspace.Presets.Count(), 1);
//Check the Preset option visibility.
Assert.AreEqual(true, ViewModel.EnablePresetOptions);
}
public void UndoAModelDeleteShouldGetTheModelInThatGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
var modelToDelete = new List <ModelBase> {
addNode
};
//Delete the model
model.DeleteModelInternal(modelToDelete);
//Check for the model count now
Assert.AreEqual(1, annotation.SelectedModels.Count());
//Undo the operation
model.CurrentWorkspace.Undo();
//Check for the model count now
Assert.AreEqual(2, annotation.SelectedModels.Count());
}
public void ParentNode_Freeze_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
//Check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//Freeeze the numbernode1 and compute the Freeze state of other nodes.
numberNode1.IsFrozen = true;
//change the value of number node1.
numberNode1.Value = "3.0";
// the number node must be frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
//the add node must be frozen and can execute state
Assert.AreEqual(addNode.IsFrozen, true);
//Since the nodes are frozen, the value of add node should not change.
AssertPreviewValue(addNode.GUID.ToString(), 3);
}
public void UndoDeletingTheGroupShouldBringTheGroupAndModelsBack()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the node for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
//Check if the group is created
Assert.IsNotNull(annotation);
//Clear the selection
DynamoSelection.Instance.ClearSelection();
//Selecting the Group should select the models within that group
var vm = ViewModel.CurrentSpaceViewModel.Annotations.FirstOrDefault();
Assert.IsNotNull(vm);
vm.Select();
Assert.AreEqual(annotation.Nodes.Count(), annotation.Nodes.Count(x => x.IsSelected));
//Execute the delete command - This should delete the entire group and models
ViewModel.DeleteCommand.Execute(null);
Assert.AreEqual(null, ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault());
//Undo the operation
ViewModel.CurrentSpace.Undo();
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Annotations.Count());
annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
Assert.IsNotNull(annotation);
Assert.AreEqual(1, annotation.Nodes.Count());
}
public void CheckIfModelExistsInSomeGroup_True_ShouldNotCreateNewAnnotation()
{
//Add a Node
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(CurrentDynamoModel.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = CurrentDynamoModel.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(CurrentDynamoModel.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//Create the group around selected node and note
Guid groupId = Guid.NewGuid();
CurrentDynamoModel.CurrentWorkspace.AddAnnotation("This is a test group", groupId);
Assert.AreEqual(CurrentDynamoModel.CurrentWorkspace.Annotations.Count(), 1);
//Tries to create new annotation with the same selection
var result = CurrentDynamoModel.CurrentWorkspace.AddAnnotation("This is a test group", Guid.NewGuid());
Assert.IsNull(result);
//Adds additional node
var extraNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(extraNode);
Assert.AreEqual(2, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
//Adds new node to selection
DynamoSelection.Instance.Selection.Add(extraNode);
//Tries to create new annotation with selected nodes.
result = CurrentDynamoModel.CurrentWorkspace.AddAnnotation("This is a test group", Guid.NewGuid());
Assert.IsNull(result);
}
public void CanAdd100NodesToClipboard()
{
var model = ViewModel.Model;
int numNodes = 100;
// create 100 nodes, and select them as you go
for (int i = 0; i < numNodes; i++)
{
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddNode(addNode, false);
Assert.AreEqual(i + 1, ViewModel.CurrentSpace.Nodes.Count);
model.AddToSelection(ViewModel.Model.CurrentWorkspace.Nodes[i]);
Assert.AreEqual(i + 1, DynamoSelection.Instance.Selection.Count);
}
model.Copy();
Assert.AreEqual(numNodes, ViewModel.Model.ClipBoard.Count);
}
public void Node_InFreeze_NotExecuteState_Test()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Freeze the node
addNode.IsFrozen = true;
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
//Check the Freeze property. Assuming only one node is selected
//this property is fetched from Nodeviewmodel. Context Menu on Workspace,
//Context menu on Node and Edit Menu toolbar refers to the same location.
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, true);
Assert.AreEqual(addNodeVm.CanToggleFrozen, true);
}
public void CanSaveAsFileWithNodesInIt()
{
int numNodes = 100;
for (int i = 0; i < numNodes; i++)
{
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(i + 1, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
}
string fn = "ruthlessTurtles.dyn";
string path = Path.Combine(TempFolder, fn);
CurrentDynamoModel.CurrentWorkspace.Save(path);
var tempFldrInfo = new DirectoryInfo(TempFolder);
Assert.AreEqual(1, tempFldrInfo.GetFiles().Length);
Assert.AreEqual(fn, tempFldrInfo.GetFiles()[0].Name);
}
public void Freeze_Test_On_WatchNode()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch();
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//check the watch node value
AssertPreviewValue(watchNode.GUID.ToString(), 3);
}
public void TestDraggedNode()
{
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"))
{
X = 16, Y = 32
};
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
NodeModel locatable = ViewModel.Model.CurrentWorkspace.Nodes.First();
var startPoint = new Point2D(8, 64);
var dn = new WorkspaceViewModel.DraggedNode(locatable, startPoint);
// Initial node position.
Assert.AreEqual(16, locatable.X);
Assert.AreEqual(32, locatable.Y);
// Move the mouse cursor to move node.
dn.Update(new Point2D(-16, 72));
Assert.AreEqual(-8, locatable.X);
Assert.AreEqual(40, locatable.Y);
}
public void UndoAnnotationText()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Update the Annotation Text
model.ExecuteCommand(
new DynCmd.UpdateModelValueCommand(
Guid.Empty, annotation.GUID, "TextBlockText",
"This is a unit test"));
Assert.AreEqual("This is a unit test", annotation.AnnotationText);
//Undo Annotation text
model.CurrentWorkspace.Undo();
//Title should be changed now.
Assert.AreEqual("This is a test group", annotation.AnnotationText);
}
public void SelectionDoesNotChangeWhenAddingAlreadySelectedNode()
{
int numNodes = 100;
// create 100 nodes, and select them as you go
for (int i = 0; i < numNodes; i++)
{
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(i + 1, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
CurrentDynamoModel.AddToSelection(CurrentDynamoModel.CurrentWorkspace.Nodes.Last());
Assert.AreEqual(i + 1, DynamoSelection.Instance.Selection.Count);
}
// the number selected stays the same
for (int i = 0; i < numNodes; i++)
{
CurrentDynamoModel.AddToSelection(CurrentDynamoModel.CurrentWorkspace.Nodes.Last());
Assert.AreEqual(numNodes, DynamoSelection.Instance.Selection.Count);
}
}
public void NodeManipulatorUnselectedNodeTest()
{
RaiseLoadedEvent(this.View);
var pntNode = new DSFunction(Model.LibraryServices.GetFunctionDescriptor("Autodesk.DesignScript.Geometry.Point.ByCoordinates"));
Model.ExecuteCommand(new DynamoModel.CreateNodeCommand(pntNode, 0, 0, true, false));
pntNode.IsSelected = false;
var dme = View.viewExtensionManager.ViewExtensions.OfType <DynamoManipulationExtension>().FirstOrDefault();
var manipulator = new MousePointManipulator(pntNode, dme);
Assert.IsNotNull(manipulator);
var manipulatorType = typeof(MousePointManipulator);
var method = manipulatorType.GetMethod("UpdatePosition", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
Assert.IsNotNull(method);
method.Invoke(manipulator, new object[] { });
}
public void TestCopyPasteGroups()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Add the group selection
DynamoSelection.Instance.Selection.Add(annotation);
//Copy the group
model.Copy();
//paste the group
model.Paste();
//there should be 2 groups in the workspace
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 2);
}
public void ChangingIsExpandedMarksGraphAsModified()
{
// Arrange
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the node for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotationViewModel = ViewModel.CurrentSpaceViewModel.Annotations.FirstOrDefault();
// Act
// Set workspace changes to false
ViewModel.CurrentSpaceViewModel.HasUnsavedChanges = false;
// Change annotationViewModel IsExpandedState
annotationViewModel.IsExpanded = !annotationViewModel.IsExpanded;
var workspaceStateAfterChangingIsExpandedFirst = ViewModel.CurrentSpaceViewModel.HasUnsavedChanges;
// Set workspace changes to false
ViewModel.CurrentSpaceViewModel.HasUnsavedChanges = false;
// Change annotationViewModel IsExpandedState
annotationViewModel.IsExpanded = !annotationViewModel.IsExpanded;
var workspaceStateAfterChangingIsExpandedSecond = ViewModel.CurrentSpaceViewModel.HasUnsavedChanges;
// Assert
Assert.IsTrue(workspaceStateAfterChangingIsExpandedFirst);
Assert.IsTrue(workspaceStateAfterChangingIsExpandedSecond);
Assert.IsTrue(ViewModel.CurrentSpaceViewModel.HasUnsavedChanges);
}
public void Node_InFreeze_NotExecuteState_Test()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Freeze the node
addNode.IsFrozen = true;
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
//Check the Freeze property. Assuming only one node is selected
//this property is fetched from Nodeviewmodel. Context Menu on Workspace,
//Context menu on Node and Edit Menu toolbar refers to the same location.
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, true);
Assert.AreEqual(addNodeVm.CanToggleFrozen, true);
}
public void CreateGroupAroundNodes()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the note for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
Assert.IsNotNull(annotation);
//verify whether group is not empty
Assert.AreNotEqual(0, annotation.Y);
Assert.AreNotEqual(0, annotation.X);
Assert.AreNotEqual(0, annotation.Width);
Assert.AreNotEqual(0, annotation.Height);
}
public void CanAddAnnotation()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
}
public void Freeze_Test_On_WatchNode()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch();
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//check the watch node value
AssertPreviewValue(watchNode.GUID.ToString(), 3);
}
public void NestedGroupTestForNodes()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the node for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
//Check if the group is created
Assert.IsNotNull(annotation);
//Clear the selection
DynamoSelection.Instance.ClearSelection();
var secondNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(secondNode, false);
//verify the node was created
Assert.AreEqual(2, ViewModel.Model.CurrentWorkspace.Nodes.Count());
//Select the nodes again - add node is in a group and secondnode is not in a group
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(secondNode);
//Check whether group can be created
Assert.AreEqual(false, ViewModel.CanAddAnnotation(null));
}
public void UngroupAllTheModelsShouldDeleteTheGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count, 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count, 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count, 1);
Assert.AreNotEqual(0, annotation.Width);
var modelsToUngroup = new List <ModelBase>();
modelsToUngroup.Add(addNote);
modelsToUngroup.Add(addNode);
//Delete the models
model.UngroupModel(modelsToUngroup);
//Group should be deleted
Assert.AreEqual(null, model.CurrentWorkspace.Annotations.FirstOrDefault());
}
public void SelectModelImplTest()
{
//Arrange
string openPath = Path.Combine(TestDirectory, @"core\DetailedPreviewMargin_Test.dyn");
RunModel(openPath);
//This will add a new DSFunction node to the current workspace
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//Select the node created (DSFunction)
DynamoSelection.Instance.Selection.Add(addNode);
var ids = DynamoSelection.Instance.Selection.OfType <NodeModel>().Select(x => x.GUID).ToList();
var selectCommand = new DynamoModel.SelectModelCommand(ids, ModifierKeys.Shift);
//Act
CurrentDynamoModel.ExecuteCommand(selectCommand);
//Assert
Assert.Greater(ids.Count, 0); //At least one guid was found
Assert.IsNotNull(selectCommand);
}
public void CanCopydAndPasteNodeWithRightOffset()
{
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
addNode.Height = 2;
addNode.Width = 2;
addNode.CenterX = 3;
addNode.CenterY = 2;
CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(1, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
CurrentDynamoModel.AddToSelection(addNode);
Assert.AreEqual(1, DynamoSelection.Instance.Selection.Count);
CurrentDynamoModel.Copy();
Assert.AreEqual(1, CurrentDynamoModel.ClipBoard.Count);
CurrentDynamoModel.Paste();
Assert.AreEqual(2, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
Assert.AreEqual(22, CurrentDynamoModel.CurrentWorkspace.Nodes.ElementAt(1).X);
Assert.AreEqual(21, CurrentDynamoModel.CurrentWorkspace.Nodes.ElementAt(1).Y);
}
public void CanUngroupNodeFromAGroup()
{
//Create a Node
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddNode(addNode, false);
//verify the node was created
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count);
//Select the node for group
DynamoSelection.Instance.Selection.Add(addNode);
//Create a Group around that node
ViewModel.AddAnnotationCommand.Execute(null);
var annotation = ViewModel.Model.CurrentWorkspace.Annotations.FirstOrDefault();
//Check if the group is created
Assert.IsNotNull(annotation);
//Clear the selection
DynamoSelection.Instance.ClearSelection();
var secondNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+"));
ViewModel.Model.CurrentWorkspace.AddNode(secondNode, false);
//verify the node was created
Assert.AreEqual(2, ViewModel.Model.CurrentWorkspace.Nodes.Count);
//Select the node
DynamoSelection.Instance.Selection.Add(addNode);
//Check whether group can be created
Assert.AreEqual(true, ViewModel.CanUngroupModel(null));
}
public void UndoAnnotationText()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Update the Annotation Text
model.ExecuteCommand(
new DynCmd.UpdateModelValueCommand(
Guid.Empty, annotation.GUID, "TextBlockText",
"This is a unit test"));
Assert.AreEqual("This is a unit test", annotation.AnnotationText);
//Undo Annotation text
model.CurrentWorkspace.Undo();
//Title should be changed now.
Assert.AreEqual("This is a test group", annotation.AnnotationText);
}
public NodeModel CreateNodeFromXml(XmlElement nodeElement, SaveContext context, ElementResolver resolver)
{
string assembly = "";
string function;
var nickname = nodeElement.Attributes["nickname"].Value;
FunctionDescriptor descriptor;
Trace.Assert(nodeElement.Attributes != null, "nodeElement.Attributes != null");
if (nodeElement.Attributes["assembly"] == null)
{
assembly = DetermineAssemblyName(nodeElement);
function = nickname.Replace(".get", ".");
}
else
{
string xmlSignature = nodeElement.Attributes["function"].Value;
string hintedSigniture =
libraryServices.FunctionSignatureFromFunctionSignatureHint(xmlSignature);
if (hintedSigniture != null)
{
nodeElement.Attributes["nickname"].Value =
libraryServices.NicknameFromFunctionSignatureHint(xmlSignature);
function = hintedSigniture;
// if the node needs additional parameters, add them here
libraryServices.AddAdditionalAttributesToNode(xmlSignature, nodeElement);
libraryServices.AddAdditionalElementsToNode(xmlSignature, nodeElement);
}
else
{
function = xmlSignature;
}
var xmlAttribute = nodeElement.Attributes["assembly"];
if (xmlAttribute != null)
{
assembly = Uri.UnescapeDataString(xmlAttribute.Value);
}
}
if (context == SaveContext.File && !string.IsNullOrEmpty(assembly))
{
var document = nodeElement.OwnerDocument;
var docPath = Nodes.Utilities.GetDocumentXmlPath(document);
assembly = Nodes.Utilities.MakeAbsolutePath(docPath, assembly);
if (libraryServices.IsLibraryLoaded(assembly))
{
descriptor = libraryServices.GetFunctionDescriptor(assembly, function);
}
else
{
// If the desired assembly is not loaded already. Check if it belongs to BuiltInFunctionGroup.
if (libraryServices.IsFunctionBuiltIn(assembly, nickname))
{
descriptor = libraryServices.GetFunctionDescriptor(function);
}
else
{
// If neither of these, Dynamo need to import the library.
try
{
libraryServices.ImportLibrary(assembly);
descriptor = libraryServices.GetFunctionDescriptor(assembly, function);
}
catch (LibraryLoadFailedException)
{
descriptor = libraryServices.GetFunctionDescriptor(function);
}
}
}
}
else
{
descriptor = libraryServices.GetFunctionDescriptor(function);
}
if (null == descriptor)
{
var inputcount = DetermineFunctionInputCount(nodeElement);
return(new DummyNode(
inputcount,
1,
nickname,
nodeElement,
assembly,
DummyNode.Nature.Unresolved));
}
DSFunctionBase result;
if (descriptor.IsVarArg)
{
result = new DSVarArgFunction(descriptor);
var akas = typeof(DSVarArgFunction).GetCustomAttribute <AlsoKnownAsAttribute>().Values;
if (nodeElement.Name != typeof(DSVarArgFunction).FullName &&
akas.All(aka => aka != nodeElement.Name))
{
VariableInputNodeController.SerializeInputCount(
nodeElement,
descriptor.Parameters.Count());
}
}
else
{
result = new DSFunction(descriptor);
}
result.Deserialize(nodeElement, context);
// In case of input parameters mismatch, use default arguments for parameters that have one
if (!descriptor.MangledName.EndsWith(function))
{
string[] oldSignature = function.Split('@');
string[] inputTypes = oldSignature.Length > 1 ? oldSignature[1].Split(',') : new string[] {};
int i = 0, j = 0;
foreach (var param in descriptor.InputParameters)
{
if (i >= inputTypes.Length || param.Item2 != inputTypes[i])
{
result.InPorts[j].UsingDefaultValue = result.InPorts[j].DefaultValue != null;
}
else
{
i++;
}
j++;
}
}
return(result);
}
internal PointOnCurveManipulator(DSFunction node, DynamoManipulationExtension manipulatorContext)
: base(node, manipulatorContext)
{
}
public void Undo_Freeze_Test()
{
var model = ViewModel.Model;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
var numberNode1Vm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode1);
Assert.IsNotNull(numberNode1Vm);
var numberNode2Vm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode2);
Assert.IsNotNull(numberNode2Vm);
//freeze number node1.
numberNode1Vm.ToggleIsFrozenCommand.Execute(null);
Assert.AreEqual(numberNode1Vm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNode1Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
//freeze number node2
numberNode2Vm.ToggleIsFrozenCommand.Execute(null);
Assert.AreEqual(numberNode2Vm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNode2Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
ViewModel.CurrentSpace.Undo();
//numbernode2 unfreeze
Assert.AreEqual(numberNode2Vm.IsFrozenExplicitly, false);
Assert.AreEqual(numberNode2Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
ViewModel.CurrentSpace.Undo();
//numbernode1 unfreeze
Assert.AreEqual(numberNode1Vm.IsFrozenExplicitly, false);
Assert.AreEqual(numberNode1Vm.CanToggleFrozen, true);
//add node is in normal state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, true);
}
public void UndoDeleteAllTheModelsShouldBringTheModelsAndGroupBack()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
var modelsToDelete = new List<ModelBase> { addNote, addNode };
//Delete the models
model.DeleteModelInternal(modelsToDelete);
//Group should be deleted
Assert.AreEqual(null, model.CurrentWorkspace.Annotations.FirstOrDefault());
//Undo the operation
model.CurrentWorkspace.Undo();
//Check for the annotation count
Assert.AreEqual(1, model.CurrentWorkspace.Annotations.Count());
//Check for the model count
annotation = model.CurrentWorkspace.Annotations.FirstOrDefault();
Assert.NotNull(annotation);
Assert.AreEqual(2, annotation.SelectedModels.Count());
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
//if we can't find this type - try to look in our load from assemblies,
//but only during testing - this is required during testing because some dlls are loaded
//using Assembly.LoadFrom using the assemblyHelper - which loads dlls into loadFrom context -
//dlls loaded with LoadFrom context cannot be found using Type.GetType() - this should
//not be an issue during normal dynamo use but if it is we can enable this code.
if (type == null && this.isTestMode == true)
{
List <Assembly> resultList;
var typeName = obj["$type"].Value <string>().Split(',').FirstOrDefault();
//this assemblyName does not usually contain version information...
var assemblyName = obj["$type"].Value <string>().Split(',').Skip(1).FirstOrDefault().Trim();
if (assemblyName != null)
{
if (this.loadedAssemblies.TryGetValue(assemblyName, out resultList))
{
var matchingTypes = resultList.Select(x => x.GetType(typeName)).ToList();
type = matchingTypes.FirstOrDefault();
}
}
}
// If the id is not a guid, makes a guid based on the id of the node
var guid = GuidUtility.tryParseOrCreateGuid(obj["Id"].Value <string>());
var replication = obj["Replication"].Value <string>();
var inPorts = obj["Inputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["Outputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
string assemblyLocation = objectType.Assembly.Location;
bool remapPorts = true;
if (type == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
CustomNodeDefinition def = null;
CustomNodeInfo info = null;
bool isUnresolved = !manager.TryGetCustomNodeData(functionId, null, false, out def, out info);
Function function = manager.CreateCustomNodeInstance(functionId, null, false, def, info);
node = function;
if (isUnresolved)
{
function.UpdatePortsForUnresolved(inPorts, outPorts);
}
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
node = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionSignature"].Value <string>();
var functionDescriptor = libraryServices.GetFunctionDescriptor(mangledName);
if (functionDescriptor == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else
{
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(functionDescriptor);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(functionDescriptor);
}
}
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
}
else if (type.ToString() == "CoreNodeModels.Formula")
{
node = (NodeModel)obj.ToObject(type);
}
else
{
node = (NodeModel)obj.ToObject(type);
// We don't need to remap ports for any nodes with json constructors which pass ports
remapPorts = false;
}
if (remapPorts)
{
RemapPorts(node, inPorts, outPorts, resolver);
}
// Cannot set Lacing directly as property is protected
node.UpdateValue(new UpdateValueParams("ArgumentLacing", replication));
node.GUID = guid;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
public void Node_AttachedTThatHasParents_ShouldNotUnfreeze_UntilAllParentsUnfreeze_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch() { X = 100, Y = 300 };
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
//check the value.
AssertPreviewValue(addNode.GUID.ToString(), 3);
//now freeze both the number nodes.
numberNode1.IsFrozen = true;
numberNode2.IsFrozen = true;
//Number nodes in frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
Assert.AreEqual(numberNode2.IsFrozen, true);
//change the value of number nodes
numberNode1.Value = "3.0";
numberNode2.Value = "3.0";
//add node in frozen and can execute state
Assert.AreEqual(addNode.IsFrozen, true);
//addnode should not change the value.
AssertPreviewValue(addNode.GUID.ToString(), 3);
Assert.AreEqual(Convert.ToInt32(watchNode.CachedValue),3);
//unfreeze one of the number node
numberNode1.IsFrozen = false;
//Number nodes in frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, false);
Assert.AreEqual(numberNode2.IsFrozen, true);
//add node should still be in frozen and can execute state
Assert.AreEqual(addNode.IsFrozen, true);
//now unfreeze the other node.
numberNode2.IsFrozen = false;
Assert.AreEqual(numberNode2.IsFrozen, false);
//now the add node should not be in frozen state
Assert.AreEqual(addNode.IsFrozen, false);
//addnode should change the value now.
AssertPreviewValue(addNode.GUID.ToString(), 6);
AssertPreviewValue(watchNode.GUID.ToString(), 6);
}
public void TestDraggedNode()
{
var addNode = new DSFunction(ViewModel.Model.LibraryServices.GetFunctionDescriptor("+")) { X = 16, Y = 32 };
ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
NodeModel locatable = ViewModel.Model.CurrentWorkspace.Nodes.First();
var startPoint = new Point2D(8, 64);
var dn = new WorkspaceViewModel.DraggedNode(locatable, startPoint);
// Initial node position.
Assert.AreEqual(16, locatable.X);
Assert.AreEqual(32, locatable.Y);
// Move the mouse cursor to move node.
dn.Update(new Point2D(-16, 72));
Assert.AreEqual(-8, locatable.X);
Assert.AreEqual(40, locatable.Y);
}
public void AddPresetShouldSetDirtyFlag()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
//Check for Dirty flag
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, false);
//add the nodes
model.CurrentWorkspace.AddAndRegisterNode(numberNode1, false);
model.CurrentWorkspace.AddAndRegisterNode(numberNode2, false);
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
//Check for Dirty flag
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, true);
//Set the dirty flag to false. Mocking the save.
model.CurrentWorkspace.HasUnsavedChanges = false;
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, false);
//connect them up
ConnectorModel.Make(numberNode1, addNode, 0, 0);
ConnectorModel.Make(numberNode2, addNode, 0, 1);
//Check for Dirty flag - After the connection the dirty flag should be set.
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, true);
//Set the dirty flag to false. Mocking the save.
model.CurrentWorkspace.HasUnsavedChanges = false;
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
//create the first state with the numbers selected
DynamoSelection.Instance.Selection.Add(numberNode1);
DynamoSelection.Instance.Selection.Add(numberNode2);
var ids = DynamoSelection.Instance.Selection.OfType <NodeModel>().Select(x => x.GUID).ToList();
//create the preset from 2 nodes
model.CurrentWorkspace.AddPreset(
"state1",
"3", ids);
Assert.AreEqual(1, model.CurrentWorkspace.Presets.Count());
//change values
numberNode1.Value = "2";
numberNode2.Value = "3";
DynamoSelection.Instance.ClearSelection();
DynamoSelection.Instance.Selection.Add(numberNode1);
DynamoSelection.Instance.Selection.Add(numberNode2);
ids = DynamoSelection.Instance.Selection.OfType <NodeModel>().Select(x => x.GUID).ToList();
model.CurrentWorkspace.AddPreset(
"state2",
"5", ids);
//Check for Dirty flag - After the Preset the dirty flag should be set.
Assert.AreEqual(model.CurrentWorkspace.HasUnsavedChanges, true);
}
public void TestCopyPasteGroup_IfItsNodeDeletedAfterCopying()
{
//Add a Node
var ws = CurrentDynamoModel.CurrentWorkspace;
var addNode = new DSFunction(CurrentDynamoModel.LibraryServices.GetFunctionDescriptor("+"));
ws.AddAndRegisterNode(addNode);
Assert.AreEqual(ws.Nodes.Count(), 1);
//Add a Note
var addNote = ws.AddNote(false, 200, 200, "This is a test note", Guid.NewGuid());
Assert.AreEqual(ws.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
var groupId = Guid.NewGuid();
var annotation = ws.AddAnnotation("This is a test group", groupId);
Assert.AreEqual(ws.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Add the group selection
DynamoSelection.Instance.Selection.Add(annotation);
//Copy the group
CurrentDynamoModel.Copy();
var modelToDelete = new List<ModelBase> { addNode };
//Delete the node
CurrentDynamoModel.DeleteModelInternal(modelToDelete);
// only the note should remain
Assert.AreEqual(1, annotation.SelectedModels.Count());
//paste the group
CurrentDynamoModel.Paste();
//there should be 2 groups in the workspace
Assert.AreEqual(ws.Annotations.Count(), 2);
var pastedGroup = ws.Annotations.First(g => g != annotation);
// group has been copied with 1 node and 1 note
Assert.AreEqual(2, pastedGroup.SelectedModels.Count());
}
public void RedoAddModelToAGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Create Another node
//Add a Node
var secondNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(secondNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 2);
DynamoSelection.Instance.ClearSelection();
//Select the group and newly created node
DynamoSelection.Instance.Selection.Add(annotation);
DynamoSelection.Instance.Selection.Add(secondNode);
var modelsToAdd = new List <ModelBase>();
modelsToAdd.Add(secondNode);
//Add the model to group
model.AddToGroup(modelsToAdd);
//Group should have the new node added
Assert.AreEqual(3, annotation.SelectedModels.Count());
DynamoSelection.Instance.ClearSelection();
//Add a new note
id = Guid.NewGuid();
var secondNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 2);
//Select the group and newly created note
DynamoSelection.Instance.Selection.Add(annotation);
DynamoSelection.Instance.Selection.Add(secondNote);
modelsToAdd.Clear();
modelsToAdd.Add(secondNote);
//Add the model to group
model.AddToGroup(modelsToAdd);
//Group should have the new note added
Assert.AreEqual(4, annotation.SelectedModels.Count());
//Undo the operation
model.CurrentWorkspace.Undo();
//Notes should not be a part of the group
Assert.AreEqual(3, annotation.SelectedModels.Count());
//Redo the operation - notes should be within that group
model.CurrentWorkspace.Redo();
Assert.AreEqual(4, annotation.SelectedModels.Count());
}
public void UndoRedoCopyPasteGroups()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Add the group selection
DynamoSelection.Instance.Selection.Add(annotation);
//Copy the group
model.Copy();
//paste the group
model.Paste();
//there should be 2 groups in the workspace
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 2);
//Undo the paste
model.CurrentWorkspace.Undo();
//there should be 1 groups in the workspace
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
//Redo the Undo
model.CurrentWorkspace.Redo();
//there should be 2 groups in the workspace
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 2);
}
public void Undo_Freeze_Test()
{
var model = ViewModel.Model;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
var numberNode1Vm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode1);
Assert.IsNotNull(numberNode1Vm);
var numberNode2Vm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode2);
Assert.IsNotNull(numberNode2Vm);
//freeze number node1.
numberNode1Vm.ToggleIsFrozenCommand.Execute(null);
Assert.AreEqual(numberNode1Vm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNode1Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
//freeze number node2
numberNode2Vm.ToggleIsFrozenCommand.Execute(null);
Assert.AreEqual(numberNode2Vm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNode2Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
ViewModel.CurrentSpace.Undo();
//numbernode2 unfreeze
Assert.AreEqual(numberNode2Vm.IsFrozenExplicitly, false);
Assert.AreEqual(numberNode2Vm.CanToggleFrozen, true);
//add node is in frozen executing state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
ViewModel.CurrentSpace.Undo();
//numbernode1 unfreeze
Assert.AreEqual(numberNode1Vm.IsFrozenExplicitly, false);
Assert.AreEqual(numberNode1Vm.CanToggleFrozen, true);
//add node is in normal state
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, false);
Assert.AreEqual(addNodeVm.CanToggleFrozen, true);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
// If we can't find this type - try to look in our load from assemblies,
// but only during testing - this is required during testing because some dlls are loaded
// using Assembly.LoadFrom using the assemblyHelper - which loads dlls into loadFrom context -
// dlls loaded with LoadFrom context cannot be found using Type.GetType() - this should
// not be an issue during normal dynamo use but if it is we can enable this code.
if (type == null && this.isTestMode == true)
{
List <Assembly> resultList;
var typeName = obj["$type"].Value <string>().Split(',').FirstOrDefault();
// This assemblyName does not usually contain version information...
var assemblyName = obj["$type"].Value <string>().Split(',').Skip(1).FirstOrDefault().Trim();
if (assemblyName != null)
{
if (this.loadedAssemblies.TryGetValue(assemblyName, out resultList))
{
var matchingTypes = resultList.Select(x => x.GetType(typeName)).ToList();
type = matchingTypes.FirstOrDefault();
}
}
}
// Check for and attempt to resolve an unknown type before proceeding
if (type == null)
{
// Attempt to resolve the type using `AlsoKnownAs`
var unresolvedName = obj["$type"].Value <string>().Split(',').FirstOrDefault();
Type newType;
nodeFactory.ResolveType(unresolvedName, out newType);
// If resolved update the type
if (newType != null)
{
type = newType;
}
}
// If the id is not a guid, makes a guid based on the id of the node
var guid = GuidUtility.tryParseOrCreateGuid(obj["Id"].Value <string>());
var replication = obj["Replication"].Value <string>();
var inPorts = obj["Inputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["Outputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
string assemblyLocation = objectType.Assembly.Location;
bool remapPorts = true;
// If type is still null at this point return a dummy node
if (type == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
// Attempt to create a valid node using the type
else if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
CustomNodeDefinition def = null;
CustomNodeInfo info = null;
bool isUnresolved = !manager.TryGetCustomNodeData(functionId, null, false, out def, out info);
Function function = manager.CreateCustomNodeInstance(functionId, null, false, def, info);
node = function;
if (isUnresolved)
{
function.UpdatePortsForUnresolved(inPorts, outPorts);
}
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
CodeBlockNodeModel codeBlockNode = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
node = codeBlockNode;
// If the code block node is in an error state read the extra port data
// and initialize the input and output ports
if (node.IsInErrorState)
{
List <string> inPortNames = new List <string>();
var inputs = obj["Inputs"];
foreach (var input in inputs)
{
inPortNames.Add(input["Name"].ToString());
}
// NOTE: This could be done in a simpler way, but is being implemented
// in this manner to allow for possible future port line number
// information being available in the file
List <int> outPortLineIndexes = new List <int>();
var outputs = obj["Outputs"];
int outputLineIndex = 0;
foreach (var output in outputs)
{
outPortLineIndexes.Add(outputLineIndex++);
}
codeBlockNode.SetErrorStatePortData(inPortNames, outPortLineIndexes);
}
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionSignature"].Value <string>();
var priorNames = libraryServices.GetPriorNames();
var functionDescriptor = libraryServices.GetFunctionDescriptor(mangledName);
string newName;
// Update the function descriptor if a newer migrated version of the node exists
if (priorNames.TryGetValue(mangledName, out newName))
{
functionDescriptor = libraryServices.GetFunctionDescriptor(newName);
}
// Use the functionDescriptor to try and restore the proper node if possible
if (functionDescriptor == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else
{
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(functionDescriptor);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(functionDescriptor);
}
}
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
}
else if (type.ToString() == "CoreNodeModels.Formula")
{
node = (NodeModel)obj.ToObject(type);
}
else
{
node = (NodeModel)obj.ToObject(type);
// if node is an customNode input symbol - assign the element resolver.
if (node is Nodes.CustomNodes.Symbol)
{
(node as Nodes.CustomNodes.Symbol).ElementResolver = ElementResolver;
}
// We don't need to remap ports for any nodes with json constructors which pass ports
remapPorts = false;
}
if (remapPorts)
{
RemapPorts(node, inPorts, outPorts, resolver, manager.AsLogger());
}
// Cannot set Lacing directly as property is protected
node.UpdateValue(new UpdateValueParams("ArgumentLacing", replication));
node.GUID = guid;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
public void Unfreeze_ParentNode_MakesATemporaryStateNode_SwitchBackToPreviousState_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch() {X = 100, Y = 300};
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//freeze add node
addNode.IsFrozen = true;
// the add node must be frozen and not executing state
Assert.AreEqual(addNode.IsFrozen, true);
//freeze number node.
numberNode1.IsFrozen = true;
// the number node must be frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
//change the value on number node 1
numberNode1.Value = "3.0";
// the add node must be frozen and in a temporary state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value on add node.
AssertPreviewValue(addNode.GUID.ToString(), 3);
//now unfreeze number node.
numberNode1.IsFrozen = false;
//now number node is not frozen
Assert.AreEqual(numberNode1.IsFrozen, false);
//this causes the add node to switch back from temporary state
//to frozen and not executing state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value on add node. Add node is not executed in the run,
// becuase the frozen nodes are removed from AST. So the value of add node
// should be 0. But the cached value should be 3, which is from the previous execution.
AssertPreviewValue(addNode.GUID.ToString(), 0);
Assert.IsNotNull(addNode.CachedValue.Data);
Assert.AreEqual(Convert.ToInt32(addNode.CachedValue.Data),3);
Assert.AreEqual(Convert.ToInt32(watchNode.CachedValue), 3);
}
public void UndoUngroupAllTheModelShouldGetTheGroupWithModels()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
var modelsToUngroup = new List<ModelBase> { addNote, addNode };
//Delete the models
model.UngroupModel(modelsToUngroup);
//Group should be deleted
Assert.AreEqual(null, model.CurrentWorkspace.Annotations.FirstOrDefault());
//Undo the Group Deletion
model.CurrentWorkspace.Undo();
//This should get the group back
Assert.AreEqual(1, model.CurrentWorkspace.Annotations.Count());
//Undo again should get the first model into the group
model.CurrentWorkspace.Undo();
annotation = model.CurrentWorkspace.Annotations.FirstOrDefault();
Assert.NotNull(annotation);
Assert.AreEqual(2, annotation.SelectedModels.Count());
}
internal PointOnCurveManipulator(DSFunction node, DynamoManipulationExtension manipulatorContext)
: base(node, manipulatorContext)
{
}
public void UnFreeze_ParentNode_UnfreezesChildNodes_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch();
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
BeginRun();
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//Add the number node to selection and call Freeze state on the workspace.
//this should freeze the number node.
numberNode1.IsFrozen = true;
// the number node must be frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
//the add node must be frozen and can execute state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//check the watch node value
AssertPreviewValue(watchNode.GUID.ToString(), 3);
//now the number node1 is frozen. change the value.
numberNode1.Value = "3.0";
//check the value of add node. it should not change.
AssertPreviewValue(addNode.GUID.ToString(), 3);
//unfreeze the input node
numberNode1.IsFrozen = false;
Assert.AreEqual(numberNode1.IsFrozen, false);
//Now the add node should be in unfreeze state
Assert.AreEqual(addNode.IsFrozen, false);
//Now the add node should get the value
AssertPreviewValue(addNode.GUID.ToString(), 5);
//check the watch node value
AssertPreviewValue(watchNode.GUID.ToString(), 5);
}
public void RedoAddModelToAGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Create Another node
//Add a Node
var secondNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(secondNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 2);
DynamoSelection.Instance.ClearSelection();
//Select the group and newly created node
DynamoSelection.Instance.Selection.Add(annotation);
DynamoSelection.Instance.Selection.Add(secondNode);
var modelsToAdd = new List<ModelBase>();
modelsToAdd.Add(secondNode);
//Add the model to group
model.AddToGroup(modelsToAdd);
//Group should have the new node added
Assert.AreEqual(3, annotation.SelectedModels.Count());
DynamoSelection.Instance.ClearSelection();
//Add a new note
id = Guid.NewGuid();
var secondNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 2);
//Select the group and newly created note
DynamoSelection.Instance.Selection.Add(annotation);
DynamoSelection.Instance.Selection.Add(secondNote);
modelsToAdd.Clear();
modelsToAdd.Add(secondNote);
//Add the model to group
model.AddToGroup(modelsToAdd);
//Group should have the new note added
Assert.AreEqual(4, annotation.SelectedModels.Count());
//Undo the operation
model.CurrentWorkspace.Undo();
//Notes should not be a part of the group
Assert.AreEqual(3, annotation.SelectedModels.Count());
//Redo the operation - notes should be within that group
model.CurrentWorkspace.Redo();
Assert.AreEqual(4, annotation.SelectedModels.Count());
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
var guid = Guid.Parse(obj["Uuid"].Value <string>());
var displayName = obj["DisplayName"].Value <string>();
//var x = obj["X"].Value<double>();
//var y = obj["Y"].Value<double>();
var inPorts = obj["InputPorts"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["OutputPorts"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionUuid"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
node = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionName"].Value <string>();
var description = libraryServices.GetFunctionDescriptor(mangledName);
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(description);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(description);
}
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionUuid"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type == typeof(Formula))
{
node = (Formula)obj.ToObject(type);
RemapPorts(node, inPorts, outPorts, resolver);
}
else
{
node = (NodeModel)obj.ToObject(type);
}
node.GUID = guid;
node.NickName = displayName;
//node.X = x;
//node.Y = y;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
public void CustomNodeWorkspaceHasUnsavedChangesPropertyIsSetOnSaveAs()
{
// open file
// make change
// saveAs
// SavedProperty is true, filePath set, file exists
var dynamoModel = ViewModel.Model;
var nodeName = "Cool node";
var catName = "Custom Nodes";
var def = dynamoModel.CustomNodeManager.CreateCustomNode(nodeName, catName, "");
Assert.IsFalse(def.HasUnsavedChanges);
var node = new DSFunction(dynamoModel.LibraryServices.GetFunctionDescriptor("+"));
def.AddAndRegisterNode(node, false);
Assert.IsTrue(def.HasUnsavedChanges);
Assert.AreEqual(1, def.Nodes.Count() );
var newPath = GetNewFileNameOnTempPath("dyf");
def.SaveAs(newPath, ViewModel.Model.EngineController.LiveRunnerRuntimeCore);
Assert.IsFalse(def.HasUnsavedChanges);
}
public void Undo_Freeze_OnParentNode_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
//add a watch node
var watchNode = new Watch() { X = 100, Y = 300 };
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(watchNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 4);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 3);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//Record for undo.
model.ExecuteCommand(
new DynCmd.UpdateModelValueCommand(
Guid.Empty, numberNode1.GUID, "IsFrozen",
numberNode1.IsFrozen.ToString()));
numberNode1.IsFrozen = true;
//Number nodes in frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
//add node in frozen and can execute state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
Assert.AreEqual(Convert.ToInt32(watchNode.CachedValue), 3);
//undo the freeze on numbernode1
model.CurrentWorkspace.Undo();
//Now change the value on number node1
numberNode1.Value = "3.0";
//now the first number node unfreeze mode.
Assert.AreEqual(numberNode1.IsFrozen, false);
//add node in normal state
Assert.AreEqual(addNode.IsFrozen, false);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 5);
AssertPreviewValue(watchNode.GUID.ToString(), 5);
}
public void Node_InTemporaryFreeze_State()
{
var model = ViewModel.Model;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output,
DynamoModel.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input,
DynamoModel.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
//Now Freeze the add node. This node has two input nodes. Note that
//input nodes are not frozen.
addNode.IsFrozen = true;
//Get the ViewModel of add node and check the Freeze property.
//This node should be in Frozen and not Executing state.
var addNodeVm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == addNode);
Assert.IsNotNull(addNodeVm);
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, true);
Assert.AreEqual(addNodeVm.CanToggleFrozen, true);
//Now freeze NumberNode1.
numberNode1.IsFrozen = true;
//Get the ViewModel of add node and check the Freeze property.
//This node should be in Frozen and not Executing state.
var numberNode1Vm = ViewModel.CurrentSpaceViewModel.Nodes.First(x => x.NodeLogic == numberNode1);
Assert.IsNotNull(numberNode1Vm);
Assert.AreEqual(numberNode1Vm.IsFrozenExplicitly, true);
Assert.AreEqual(numberNode1Vm.CanToggleFrozen, true);
//Now check the add node. Freeze property will be unchecked and disabled.
Assert.AreEqual(addNodeVm.IsFrozenExplicitly, true);
Assert.AreEqual(addNodeVm.CanToggleFrozen, false);
}
public void ChangeTheBackgroundForAGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
//Check the default color - it should be green
Assert.AreEqual(annotation.GroupBackground, annotation.Background);
//change the color
annotation.Background = "#ff7bac";
//Check the color - it should be ff7bac
Assert.AreEqual("#ff7bac", annotation.Background);
}
public void HomeWorkspaceHasUnsavedChangesPropertyIsSetOnSaveAs()
{
// open file
// make change
// saveAs
// SavedProperty is true, filePath set, file exists
// get empty workspace
var dynamoModel = ViewModel.Model;
Assert.IsNotNull(dynamoModel.CurrentWorkspace);
Assert.IsAssignableFrom(typeof(HomeWorkspaceModel), dynamoModel.CurrentWorkspace);
// make change
var node = new DSFunction(dynamoModel.LibraryServices.GetFunctionDescriptor("+"));
dynamoModel.CurrentWorkspace.AddAndRegisterNode(node, false);
Assert.IsTrue(ViewModel.Model.CurrentWorkspace.HasUnsavedChanges);
Assert.AreEqual(1, ViewModel.Model.CurrentWorkspace.Nodes.Count());
// save
var newPath = GetNewFileNameOnTempPath("dyn");
ViewModel.Model.CurrentWorkspace.SaveAs(newPath, ViewModel.Model.EngineController.LiveRunnerRuntimeCore);
// check expected
Assert.IsFalse(ViewModel.Model.CurrentWorkspace.HasUnsavedChanges);
}
public void Unfreeze_ParentNode_MakesATemporaryStateNode_SwitchBackToPreviousState_Test()
{
var model = CurrentDynamoModel;
//create some numbers
var numberNode1 = new DoubleInput();
numberNode1.Value = "1";
var numberNode2 = new DoubleInput();
numberNode2.Value = "2";
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode1, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(numberNode2, 0, 0, true, false));
model.ExecuteCommand(new DynamoModel.CreateNodeCommand(addNode, 0, 0, true, false));
//connect them up
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode1.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 0, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(numberNode2.GUID, 0, PortType.Output, DynCmd.MakeConnectionCommand.Mode.Begin));
model.ExecuteCommand(new DynamoModel.MakeConnectionCommand(addNode.GUID, 1, PortType.Input, DynCmd.MakeConnectionCommand.Mode.End));
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 3);
Assert.AreEqual(model.CurrentWorkspace.Connectors.Count(), 2);
//check the value
AssertPreviewValue(addNode.GUID.ToString(), 3);
//freeze add node
addNode.IsFrozen = true;
// the add node must be frozen and not executing state
Assert.AreEqual(addNode.IsFrozen, true);
//freeze number node.
numberNode1.IsFrozen = true;
// the number node must be frozen and not executing state
Assert.AreEqual(numberNode1.IsFrozen, true);
//change the value on number node 1
numberNode1.Value = "3.0";
// the add node must be frozen and in a temporary state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value on add node.
AssertPreviewValue(addNode.GUID.ToString(), 3);
//now unfreeze number node.
numberNode1.IsFrozen = false;
//now number node is not frozen
Assert.AreEqual(numberNode1.IsFrozen, false);
//this causes the add node to switch back from temporary state
//to frozen and not executing state
Assert.AreEqual(addNode.IsFrozen, true);
//check the value on add node.
AssertPreviewValue(addNode.GUID.ToString(), 5);
}
public void UndoAModelDeleteShouldGetTheModelInThatGroup()
{
//Add a Node
var model = CurrentDynamoModel;
var addNode = new DSFunction(model.LibraryServices.GetFunctionDescriptor("+"));
model.CurrentWorkspace.AddAndRegisterNode(addNode, false);
Assert.AreEqual(model.CurrentWorkspace.Nodes.Count(), 1);
//Add a Note
Guid id = Guid.NewGuid();
var addNote = model.CurrentWorkspace.AddNote(false, 200, 200, "This is a test note", id);
Assert.AreEqual(model.CurrentWorkspace.Notes.Count(), 1);
//Select the node and notes
DynamoSelection.Instance.Selection.Add(addNode);
DynamoSelection.Instance.Selection.Add(addNote);
//create the group around selected nodes and notes
Guid groupid = Guid.NewGuid();
var annotation = model.CurrentWorkspace.AddAnnotation("This is a test group", groupid);
Assert.AreEqual(model.CurrentWorkspace.Annotations.Count(), 1);
Assert.AreNotEqual(0, annotation.Width);
var modelToDelete = new List<ModelBase> { addNode };
//Delete the model
model.DeleteModelInternal(modelToDelete);
//Check for the model count now
Assert.AreEqual(1, annotation.SelectedModels.Count());
//Undo the operation
model.CurrentWorkspace.Undo();
//Check for the model count now
Assert.AreEqual(2, annotation.SelectedModels.Count());
}
