public static void ExportToSTL(DynamoModel dynamoModel, string path, string modelName)
{
var packages = dynamoModel.Nodes
.Where(node => node.HasRenderPackages)
.SelectMany(rp=>rp.RenderPackages)
.Cast<RenderPackage>()
.Where(rp=>rp.TriangleVertices.Count % 9 == 0)
.ToList();
var n = packages.SelectMany(rp => rp.TriangleNormals).ToList();
var v = packages.SelectMany(rp => rp.TriangleVertices).ToList();
using (TextWriter tw = new StreamWriter(path))
{
tw.WriteLine("solid {0}", modelName);
int nCount = 0;
for (int i = 0; i < v.Count(); i += 9)
{
tw.WriteLine("\tfacet normal {0} {1} {2}", n[nCount], n[nCount+1], n[nCount+2]);
tw.WriteLine("\t\touter loop");
tw.WriteLine("\t\t\tvertex {0} {1} {2}", v[i], v[i+1], v[i+2]);
tw.WriteLine("\t\t\tvertex {0} {1} {2}", v[i+3], v[i+4], v[i+5]);
tw.WriteLine("\t\t\tvertex {0} {1} {2}", v[i+6], v[i+7], v[i+8]);
tw.WriteLine("\t\tendloop");
tw.WriteLine("\tendfacet");
nCount += 3;
}
tw.WriteLine("endsolid {0}", modelName);
}
}
public DynamoViewModel(DynamoController controller)
{
//MVVM: Instantiate the model
_model = new DynamoModel();
_model.Workspaces.CollectionChanged += Workspaces_CollectionChanged;
_model.PropertyChanged += _model_PropertyChanged;
dynSettings.Controller.DynamoModel = _model;
_model.AddHomeWorkspace();
_model.CurrentSpace = _model.HomeSpace;
Controller = controller;
sw = new StringWriter();
ConnectorType = ConnectorType.BEZIER;
#region Initialize Commands
GoToWikiCommand = new DelegateCommand(GoToWiki, CanGoToWiki);
ReportABugCommand = new DelegateCommand(ReportABug, CanReportABug);
GoToSourceCodeCommand = new DelegateCommand(GoToSourceCode, CanGoToSourceCode);
CleanupCommand = new DelegateCommand(Cleanup, CanCleanup);
ExitCommand = new DelegateCommand<object>(Exit, CanExit);
NewHomeWorkspaceCommand = new DelegateCommand(MakeNewHomeWorkspace, CanMakeNewHomeWorkspace);
ShowSaveImageDialogAndSaveResultCommand = new DelegateCommand(ShowSaveImageDialogAndSaveResult, CanShowSaveImageDialogAndSaveResult);
ShowOpenDialogAndOpenResultCommand = new DelegateCommand(ShowOpenDialogAndOpenResult, CanShowOpenDialogAndOpenResultCommand);
ShowSaveDialogIfNeededAndSaveResultCommand = new DelegateCommand(ShowSaveDialogIfNeededAndSaveResult, CanShowSaveDialogIfNeededAndSaveResultCommand);
ShowSaveDialogAndSaveResultCommand = new DelegateCommand(ShowSaveDialogAndSaveResult, CanShowSaveDialogAndSaveResultCommand);
ShowNewFunctionDialogCommand = new DelegateCommand(ShowNewFunctionDialog, CanShowNewFunctionDialogCommand);
SaveCommand = new DelegateCommand(Save, CanSave);
OpenCommand = new DelegateCommand<object>(Open, CanOpen);
SaveAsCommand = new DelegateCommand<object>(SaveAs, CanSaveAs);
ClearCommand = new DelegateCommand(Clear, CanClear);
HomeCommand = new DelegateCommand(Home, CanGoHome);
LayoutAllCommand = new DelegateCommand(LayoutAll, CanLayoutAll);
CopyCommand = new DelegateCommand<object>(Copy, CanCopy);
PasteCommand = new DelegateCommand<object>(Paste, CanPaste);
ToggleConsoleShowingCommand = new DelegateCommand(ToggleConsoleShowing, CanToggleConsoleShowing);
ToggleFullscreenWatchShowingCommand = new DelegateCommand(ToggleFullscreenWatchShowing, CanToggleFullscreenWatchShowing);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
CancelRunCommand = new DelegateCommand(CancelRun, CanCancelRun);
SaveImageCommand = new DelegateCommand<object>(SaveImage, CanSaveImage);
ClearLogCommand = new DelegateCommand(ClearLog, CanClearLog);
RunExpressionCommand = new DelegateCommand<object>(RunExpression,CanRunExpression);
ShowPackageManagerCommand = new DelegateCommand(ShowPackageManager,CanShowPackageManager);
GoToWorkspaceCommand = new DelegateCommand<object>(GoToWorkspace, CanGoToWorkspace);
DisplayFunctionCommand = new DelegateCommand<object>(DisplayFunction, CanDisplayFunction);
SetConnectorTypeCommand = new DelegateCommand<object>(SetConnectorType, CanSetConnectorType);
CreateNodeCommand = new DelegateCommand<object>(CreateNode, CanCreateNode);
CreateConnectionCommand = new DelegateCommand<object>(CreateConnection, CanCreateConnection);
AddNoteCommand = new DelegateCommand<object>(AddNote, CanAddNote);
DeleteCommand = new DelegateCommand<object>(Delete, CanDelete);
SelectNeighborsCommand = new DelegateCommand<object>(SelectNeighbors, CanSelectNeighbors);
AddToSelectionCommand = new DelegateCommand<object>(AddToSelection, CanAddToSelection);
PostUIActivationCommand = new DelegateCommand(PostUIActivation, CanDoPostUIActivation);
RefactorCustomNodeCommand = new DelegateCommand(RefactorCustomNode, CanRefactorCustomNode);
ShowHideConnectorsCommand = new DelegateCommand(ShowConnectors, CanShowConnectors);
#endregion
}
public RenderManager(VisualizationManager vizManager, DynamoModel dynamoModel)
{
this.visualizationManager = vizManager;
this.dynamoModel = dynamoModel;
controllerThread = new Thread(RenderLoopController);
controllerThread.Name = "RenderManager controller thread";
controllerThread.IsBackground = true;
controllerThread.Start();
}
public RevitVisualizationManager(DynamoModel dynamoModel) : base(dynamoModel)
{
if (dynamoModel.Context == Context.VASARI_2014 ||
dynamoModel.Context == Context.REVIT_2015)
{
AlternateDrawingContextAvailable = true;
DrawToAlternateContext = false;
AlternateContextName = dynamoModel.Context;
RequestAlternateContextClear += CleanupVisualizations;
dynamoModel.CleaningUp += CleanupVisualizations;
}
else
{
AlternateDrawingContextAvailable = false;
}
}
public void Defect_MAGN_942_GreaterThan()
{
DynamoModel model = Controller.DynamoModel;
string openPath = Path.Combine(GetTestDirectory(), @"core\DynamoDefects\Defect_MAGN_942_GreaterThan.dyn");
model.Open(openPath);
dynSettings.Controller.RunExpression(null);
var equal = model.CurrentWorkspace.NodeFromWorkspace <Map>("7ec8271d-be03-4d53-ae78-b94c4db484e1");
FSharpList <FScheme.Value> actual = equal.GetValue(0).GetListFromFSchemeValue();
Assert.AreEqual(11, actual.Length);
Assert.AreEqual(0, actual[0].GetDoubleFromFSchemeValue());
Assert.AreEqual(0, actual[1].GetDoubleFromFSchemeValue());
Assert.AreEqual(1, actual[7].GetDoubleFromFSchemeValue());
Assert.AreEqual(1, actual[9].GetDoubleFromFSchemeValue());
}
public void Start(DynamoModel model)
{
//Whether enabled or not, we still record the startup.
var service = Service.Instance;
//Some clients such as Revit may allow start/close Dynamo multiple times
//in the same session so register only if the factory is not registered.
if (service.GetTrackerFactory(GATrackerFactory.Name) == null)
{
service.Register(new GATrackerFactory(ANALYTICS_PROPERTY));
}
StabilityCookie.Startup();
heartbeat = Heartbeat.GetInstance(model);
logger = new UsageLog("Dynamo", UserId, SessionId);
}
public void testEqual_NumberInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testEqualNumberInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("75e739ed-082f-4eaa-8fd4-d0b88f44eaf4");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("40e72290-42ce-457b-9153-23f4d63b7a9b");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 1;
double expectedResult2 = 0;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testLessThan_StringInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testLessThanStringInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("b300d0f8-dee2-4eb8-ac13-e77e337ebbf2");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("f4e793a3-f01f-42d8-b084-884e4155dbd8");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 1;
double expectedResult2 = 0;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testNot_NumberInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testNotNumberInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("893a8746-b74f-4078-a125-8b96a48ec782");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("6fa95218-d960-4069-ab38-0fec7c815e06");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 0;
double expectedResult2 = 1;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testLessThan_NumberInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testLessThanNumberInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("fee9b04f-420f-4e2e-8dc1-20b7732d038c");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("9093b858-7e36-4cc9-b665-3297bbabd280");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 1;
double expectedResult2 = 0;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testGreaterThan_StringInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testGreaterThanStringInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("bc06bc35-51f7-4db4-bbb5-f687449ec87b");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("8c4d02fe-e6cb-4ff7-9093-82f246e1a88d");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 0;
double expectedResult2 = 1;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testGreaterThan_NumberInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testGreaterThanNumberInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("97646425-6c25-4692-87c8-23c0a1aeda09");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("3483359c-8fb4-4c37-be95-e56827920430");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 0;
double expectedResult2 = 1;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void testEqual_StringInput()
{
DynamoModel model = Controller.DynamoModel;
string testFilePath = Path.Combine(logicTestFolder, "testEqualStringInput.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
Watch watch1 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("171ec867-1434-444c-aa3a-8e61e167c477");
Watch watch2 = model.CurrentWorkspace.NodeFromWorkspace <Watch>("ce42fdfb-6fca-4da5-a8a5-fb65dd03567d");
double actualResult1 = watch1.GetValue(0).GetDoubleFromFSchemeValue();
double actualResult2 = watch2.GetValue(0).GetDoubleFromFSchemeValue();
double expectedResult1 = 1;
double expectedResult2 = 0;
Assert.AreEqual(expectedResult1, actualResult1);
Assert.AreEqual(expectedResult2, actualResult2);
}
public void Defect_MAGN_942_GreaterThanOrEqual()
{
DynamoModel model = Controller.DynamoModel;
string openPath = Path.Combine(GetTestDirectory(), @"core\DynamoDefects\Defect_MAGN_942_GreaterThanOrEqual.dyn");
model.Open(openPath);
dynSettings.Controller.RunExpression(null);
var equal = model.CurrentWorkspace.NodeFromWorkspace <Map>("3806c656-56bd-4878-9082-b2d27644abd1");
FSharpList <FScheme.Value> actual = equal.GetValue(0).GetListFromFSchemeValue();
Assert.AreEqual(11, actual.Length);
Assert.AreEqual(0, actual[2].GetDoubleFromFSchemeValue());
Assert.AreEqual(0, actual[4].GetDoubleFromFSchemeValue());
Assert.AreEqual(1, actual[6].GetDoubleFromFSchemeValue());
Assert.AreEqual(1, actual[8].GetDoubleFromFSchemeValue());
}
public void Defect_MAGN_4046()
{
//Detail steps are here http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-4046
DynamoModel model = ViewModel.Model;
string openPath = Path.Combine(GetTestDirectory(), @"core\DynamoDefects\Defect_MAGN_4046.dyn");
RunModel(openPath);
AssertPreviewCount("354ec30b-b13f-4399-beb2-a68753c09bfc", 1);
IntegerSlider integerInput = model.CurrentWorkspace.NodeFromWorkspace
("65d226ea-cfb5-4c5a-940e-a5c4eab1915d") as IntegerSlider;
for (int i = 0; i <= 10; i++)
{
integerInput.Value = 5 + i;
RunCurrentModel();
AssertPreviewCount("354ec30b-b13f-4399-beb2-a68753c09bfc", 1);
}
}
protected void RunCommandsFromFile(string commandFileName,
bool autoRun = false, CommandCallback commandCallback = null)
{
string commandFilePath = SystemTestBase.GetTestDirectory(ExecutingDirectory);
commandFilePath = Path.Combine(commandFilePath, @"core\recorded\");
commandFilePath = Path.Combine(commandFilePath, commandFileName);
if (this.ViewModel != null)
{
var message = "Multiple DynamoViewModel instances detected!";
throw new InvalidOperationException(message);
}
var model = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
StartInTestMode = true
});
ViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
DynamoModel = model,
CommandFilePath = commandFilePath
});
ViewModel.HomeSpace.RunSettings.RunType = autoRun ?
RunType.Automatic :
RunType.Manual;
RegisterCommandCallback(commandCallback);
// Create the view.
var dynamoView = new DynamoView(this.ViewModel);
dynamoView.ShowDialog();
Assert.IsNotNull(ViewModel);
Assert.IsNotNull(ViewModel.Model);
Assert.IsNotNull(ViewModel.Model.CurrentWorkspace);
workspace = ViewModel.Model.CurrentWorkspace;
workspaceViewModel = ViewModel.CurrentSpaceViewModel;
}
public virtual void Start()
{
var assemblyPath = Assembly.GetExecutingAssembly().Location;
preloader = new Preloader(Path.GetDirectoryName(assemblyPath));
preloader.Preload();
CreateTemporaryFolder();
// Setup Temp PreferenceSetting Location for testing
PreferenceSettings.DynamoTestPath = Path.Combine(TempFolder, "UserPreferenceTest.xml");
TestPathResolver pathResolver = null;
var preloadedLibraries = new List <string>();
GetLibrariesToPreload(preloadedLibraries);
if (preloadedLibraries.Any())
{
// Only when any library needs preloading will a path resolver be
// created, otherwise DynamoModel gets created without preloading
// any library.
//
pathResolver = new TestPathResolver();
foreach (var preloadedLibrary in preloadedLibraries.Distinct())
{
pathResolver.AddPreloadLibraryPath(preloadedLibrary);
}
}
Model = DynamoModel.Start(
this.CreateStartConfiguration(pathResolver));
ViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
DynamoModel = Model
});
//create the view
View = new DynamoView(ViewModel);
View.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
private void ExecThread()
{
Thread.Sleep(WARMUP_DELAY_MS);
while (true)
{
try
{
StabilityCookie.WriteUptimeBeat(DateTime.Now.Subtract(startTime));
//Disable heartbeat to avoid 150 event/session limit
//InstrumentationLogger.LogAnonymousEvent("Heartbeat", "ApplicationLifeCycle", GetVersionString());
String usage = PackFrequencyDict(ComputeNodeFrequencies());
String errors = PackFrequencyDict(ComputeErrorFrequencies());
Analytics.LogPiiInfo("Node-usage", usage);
Analytics.LogPiiInfo("Nodes-with-errors", errors);
DynamoModel.OnRequestDispatcherInvoke(
() =>
{
string workspace = dynamoModel.CurrentWorkspace == null ? string.Empty :
dynamoModel.CurrentWorkspace.GetStringRepOfWorkspace();
Analytics.LogPiiInfo("Workspace", workspace);
});
}
catch (Exception e)
{
Debug.WriteLine("Exception in Heartbeat " + e);
}
// The following call will return "true" if the event is
// signaled, which can only happen when "DestroyInternal"
// is called as the application is shutting down. Otherwise,
// when the wait time ellapsed, the loop continues to log
// the next set of information.
//
if (shutdownEvent.WaitOne(HEARTBEAT_INTERVAL_MS))
{
break;
}
}
}
protected virtual void StartDynamo(TestSessionConfiguration testConfig)
{
preloader = new Preloader(testConfig.DynamoCorePath, testConfig.RequestedLibraryVersion);
preloader.Preload();
var preloadedLibraries = new List <string>();
GetLibrariesToPreload(preloadedLibraries);
if (preloadedLibraries.Any())
{
if (pathResolver == null)
{
pathResolver = new TestPathResolver();
}
var pr = pathResolver as TestPathResolver;
foreach (var preloadedLibrary in preloadedLibraries.Distinct())
{
pr.AddPreloadLibraryPath(preloadedLibrary);
}
}
Model = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
StartInTestMode = true,
PathResolver = pathResolver,
GeometryFactoryPath = preloader.GeometryFactoryPath,
UpdateManager = this.UpdateManager
});
ViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
DynamoModel = Model
});
//create the view
View = new DynamoView(ViewModel);
View.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
public void TestSplitStringFileInput()
{
DynamoModel model = controller.DynamoModel;
string testFilePath = Path.Combine(localDynamoStringTestFloder, "TestSplitString_fromFile.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
var watch = getWatchNodeFromCurrentSpace(model, "f72f6210-b32f-4dc4-9b2a-61f0144a0109");
String expected1 = "today";
String expected2 = "yesterday";
String expected3 = "tomorrow";
FSharpList <FScheme.Value> splitedStrings = getListFromFSchemeValue(watch.GetValue(0));
Assert.AreEqual(expected1, getStringFromFSchemeValue(splitedStrings[0]));
Assert.AreEqual(expected2, getStringFromFSchemeValue(splitedStrings[1]));
Assert.AreEqual(expected3, getStringFromFSchemeValue(splitedStrings[2]));
}
public void Defect_MAGN_942_GreaterThanOrEqual()
{
Assert.Inconclusive("Porting : Formula");
DynamoModel model = Controller.DynamoModel;
string openPath = Path.Combine(GetTestDirectory(), @"core\DynamoDefects\Defect_MAGN_942_GreaterThanOrEqual.dyn");
RunModel(openPath);
Dictionary <int, object> validationData = new Dictionary <int, object>()
{
{ 2, 0 },
{ 4, 0 },
{ 6, 1 },
{ 8, 1 },
};
SelectivelyAssertPreviewValues("3806c656-56bd-4878-9082-b2d27644abd1", validationData);
}
private void RestartTestSetup(bool startInTestMode)
{
// Shutdown Dynamo and restart it
View.Close();
View = null;
if (ViewModel != null)
{
var shutdownParams = new DynamoViewModel.ShutdownParams(
shutdownHost: false, allowCancellation: false);
ViewModel.PerformShutdownSequence(shutdownParams);
ViewModel = null;
}
// Setup Temp PreferenceSetting Location for testing
PreferenceSettings.DynamoTestPath = Path.Combine(TempFolder, "UserPreferenceTest.xml");
Model = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
StartInTestMode = startInTestMode,
ProcessMode = startInTestMode
? TaskProcessMode.Synchronous
: TaskProcessMode.Asynchronous
});
ViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
DynamoModel = Model
});
var expectedState = startInTestMode
? DynamoModel.DynamoModelState.StartedUIless
: DynamoModel.DynamoModelState.StartedUI;
Assert.AreEqual(ViewModel.Model.State, expectedState);
//create the view
View = new DynamoView(ViewModel);
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
public void MAGN_5041_NurbsCurveExtend()
{
// Details are available in defect
// http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-5041
// Curve.Extend, Curve.ExtendEnd, Curve.ExtendStart returns null for
// distance = 0 on NurbsCurves
DynamoModel model = ViewModel.Model;
string openPath = Path.Combine(TestDirectory,
@"core\WorkflowTestFiles\\GeometryDefects\MAGN_5041_NurbsCurveExtend.dyn");
RunModel(openPath);
AssertNoDummyNodes();
// check all the nodes and connectors are loaded
Assert.AreEqual(9, model.CurrentWorkspace.Nodes.Count);
Assert.AreEqual(13, model.CurrentWorkspace.Connectors.Count());
var nurbsCurve = GetPreviewValue("0cd25749-5f49-4e2c-82f7-ac278e35ac7f") as NurbsCurve;
Assert.IsNotNull(nurbsCurve);
var curveExtend = GetPreviewValue("be028256-7186-4e96-9977-38981feed66b") as Curve;
Assert.IsNotNull(curveExtend);
var curveExtendEnd = GetPreviewValue("e09faec4-65c4-4d1f-b769-ceb5e10c47a0") as Curve;
Assert.IsNotNull(curveExtendEnd);
var curveExtendStart = GetPreviewValue("1da11460-3a04-4d1a-beb8-a434c0fd206c") as Curve;
Assert.IsNotNull(curveExtendStart);
// Checking length of Extended Curve is same as
// original Nurbs Curve as extend distance is 0
Assert.AreEqual(curveExtend.Length, nurbsCurve.Length);
Assert.AreEqual(curveExtendEnd.Length, nurbsCurve.Length);
Assert.AreEqual(curveExtendStart.Length, nurbsCurve.Length);
}
/// <summary>
/// Places watch node at the midpoint of the connector
/// </summary>
internal List <ModelBase> PlaceWatchNode(ConnectorModel connector, IEnumerable <Point> connectorPinLocations, List <ModelBase> allDeletedModels)
{
var createdModels = new List <ModelBase>();
NodeModel startNode = ViewModel.ConnectorModel.Start.Owner;
NodeModel endNode = ViewModel.ConnectorModel.End.Owner;
this.Dispatcher.Invoke(() =>
{
var watchNode = new Watch();
var nodeX = CurrentPosition.X - (watchNode.Width / 2);
var nodeY = CurrentPosition.Y - (watchNode.Height / 2);
DynamoModel.ExecuteCommand(new DynamoModel.CreateNodeCommand(watchNode, nodeX, nodeY, false, false));
createdModels.Add(watchNode);
WireNewNode(DynamoModel, startNode, endNode, watchNode, connector, connectorPinLocations, createdModels, allDeletedModels);
});
return(createdModels);
}
public void WriteToExcel()
{
// Create automation for Dynamo file : 05 Write to Excel.dyn
// http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-7214
DynamoModel model = ViewModel.Model;
string openPath = Path.Combine(TestDirectory, @"core\WorkflowTestFiles\01 Dynamo Basics\05 Write To Excel.dyn");
RunModel(openPath);
AssertNoDummyNodes();
//check the number of nodes and connectors
Assert.AreEqual(14, model.CurrentWorkspace.Connectors.Count());
Assert.AreEqual(12, model.CurrentWorkspace.Nodes.Count);
// check List.Transpose
var listTranspose = "53ee9988-6ed7-497f-92d8-2132f1a76ae3";
AssertPreviewCount(listTranspose, 65);
}
public void TestStringReplaceMultipleInput()
{
DynamoModel model = ViewModel.Model;
string testFilePath = Path.Combine(localDynamoStringTestFloder, "TestStringReplace_multipleInput.dyn");
RunModel(testFilePath);
AssertPreviewValue("36774b24-e6dd-41b1-889b-3847aa0ad6ee",
new string[] {
"I am going to meet him and Dave.",
"I am going to meet Bryan and him."
});
AssertPreviewValue("b61394da-efa0-4e7e-aec7-9f55a90e8449",
new string[] {
"My name is Dave.",
"Dave is my name."
});
}
public void CustomizeView(Send model, NodeView nodeView)
{
dynamoModel = nodeView.ViewModel.DynamoViewModel.Model;
dynamoViewModel = nodeView.ViewModel.DynamoViewModel;
syncContext = new DispatcherSynchronizationContext(nodeView.Dispatcher);
sendNode = model;
sendNode.OnInputsChanged += InputsChanged;
var ui = new SendUi();
nodeView.inputGrid.Children.Add(ui);
//bindings
ui.DataContext = model;
//ui.Loaded += model.AddedToDocument;
ui.SendStreamButton.Click += SendStreamButtonClick;
ui.CancelSendStreamButton.Click += CancelSendStreamButtonClick;
}
public void TestStringCaseNormalInput()
{
DynamoModel model = controller.DynamoModel;
string testFilePath = Path.Combine(localDynamoStringTestFloder, "TestStringCase_normal.dyn");
model.Open(testFilePath);
dynSettings.Controller.RunExpression(null);
var watch1 = getWatchNodeFromCurrentSpace(model, "f72f6210-b32f-4dc4-9b2a-61f0144a0109");
var watch2 = getWatchNodeFromCurrentSpace(model, "77a8c84b-b5bb-46f1-a550-7b3d5441c0a1");
String actual1 = getStringFromFSchemeValue(watch1.GetValue(0));
String actual2 = getStringFromFSchemeValue(watch2.GetValue(0));
String expected1 = "RAINY DAY";
String expected2 = "rainy day";
Assert.AreEqual(expected1, actual1);
Assert.AreEqual(expected2, actual2);
}
protected void StartDynamo()
{
DynamoPathManager.Instance.InitializeCore(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
DynamoPathManager.Instance.PreloadASMLibraries();
var model = DynamoModel.Start(
new DynamoModel.StartConfiguration()
{
StartInTestMode = true
});
this.ViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
DynamoModel = model
});
}
private static string DoPackageFileOperationsAndZip(DynamoModel dynamoModel, Package pkg, List <string> files, PackageUploadHandle uploadHandle)
{
uploadHandle.UploadState = PackageUploadHandle.State.Copying;
DirectoryInfo rootDir, dyfDir, binDir, extraDir;
FormPackageDirectory(dynamoModel.Loader.PackageLoader.RootPackagesDirectory, pkg.Name, out rootDir, out dyfDir, out binDir, out extraDir); // shouldn't do anything for pkg versions
pkg.RootDirectory = rootDir.FullName;
WritePackageHeader(pkg.Header, rootDir);
CopyFilesIntoPackageDirectory(files, dyfDir, binDir, extraDir);
RemoveDyfFiles(files, dyfDir);
RemapCustomNodeFilePaths(dynamoModel.CustomNodeManager, files, dyfDir.FullName);
uploadHandle.UploadState = PackageUploadHandle.State.Compressing;
var zipPath = Greg.Utility.FileUtilities.Zip(rootDir.FullName);
return(zipPath);
}
public void Init()
{
extensionsPath = Path.Combine(Directory.GetCurrentDirectory(), "extensions");
extMock = new Mock <IExtension>();
extMock.Setup(ext => ext.Ready(It.IsAny <ReadyParams>())).Callback((ReadyParams r) => ExtensionReadyCallback(r));
cmdExecutionState = -1;
model = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
StartInTestMode = true,
Extensions = new List <IExtension> {
extMock.Object
},
ProcessMode = TaskProcessMode.Synchronous
});
model.ExtensionManager.ExtensionAdded += OnExtensionAdded;
model.ExtensionManager.ExtensionRemoved += OnExtensionRemoved;
}
/// <summary>
/// Helper function to load new custom nodes and packages.
/// </summary>
/// <param name="newPaths">New package paths to load custom nodes and packages from.</param>
/// <param name="preferences">Can be a temporary local preferences object.</param>
/// <param name="customNodeManager"></param>
private void LoadCustomNodesAndPackagesHelper(IEnumerable <string> newPaths, IPreferences preferences,
CustomNodeManager customNodeManager)
{
foreach (var path in preferences.CustomPackageFolders)
{
// Append the definitions subdirectory for custom nodes.
var dir = path == DynamoModel.BuiltInPackagesToken ? PathManager.BuiltinPackagesDirectory : path;
dir = TransformPath(dir, PathManager.DefinitionsDirectoryName);
customNodeManager.AddUninitializedCustomNodesInPath(dir, false, false);
}
foreach (var path in newPaths)
{
if (DynamoModel.IsDisabledPath(path, preferences))
{
Log(string.Format(Resources.PackagesDirectorySkipped, path));
continue;
}
else
{
ScanPackageDirectories(path, preferences);
}
}
if (pathManager != null)
{
foreach (var pkg in LocalPackages)
{
if (Directory.Exists(pkg.BinaryDirectory))
{
pathManager.AddResolutionPath(pkg.BinaryDirectory);
}
}
}
if (LocalPackages.Any())
{
// Load only those recently addeed local packages (that are located in any of the new paths)
var newPackages = LocalPackages.Where(x => newPaths.Any(y => x.RootDirectory.Contains(y)));
LoadPackages(newPackages);
}
}
/// <summary>
/// View customization.
/// </summary>
/// <param name="model"></param>
/// <param name="nodeView"></param>
public void CustomizeView(MandrillWindowNodeModel model, NodeView nodeView)
{
_dynamoModel = nodeView.ViewModel.DynamoViewModel.Model;
_dynamoViewModel = nodeView.ViewModel.DynamoViewModel;
_mandrillNode = model;
// load button control into node, set data context
var helloDynamoControl = new Window.LaunchWindowButtonControl();
nodeView.inputGrid.Width = 100;
nodeView.inputGrid.Children.Add(helloDynamoControl);
helloDynamoControl.DataContext = model;
// attach mandrill window to Dynamo control
MandrillWindowNodeModel.Dv = FindUpVisualTree <DynamoView>(nodeView);
// attach input update and new window events to Dynamo control
_mandrillNode.RequestChangeHtmlString += UpdateHtmlString;
model.RequestNewWindow += CreateNewWindow;
}
public void CustomizeView(ColorRange model, NodeView nodeView)
{
dynamoModel = nodeView.ViewModel.DynamoViewModel.Model;
dynamoViewModel = nodeView.ViewModel.DynamoViewModel;
syncContext = new DispatcherSynchronizationContext(nodeView.Dispatcher);
colorRangeNode = model;
gradientImage = new Image
{
Stretch = Stretch.Fill,
Width = 200,
Height = Configurations.PortHeightInPixels * 3
};
nodeView.inputGrid.Children.Add(gradientImage);
colorRangeNode.RequestChangeColorRange += UpdateColorRange;
UpdateColorRange();
}
public WorkspaceMigrations(DynamoModel dynamoModel)
{
this.dynamoModel = dynamoModel;
}
protected void StartDynamo()
{
DynamoPathManager.Instance.InitializeCore(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
DynamoPathManager.PreloadAsmLibraries(DynamoPathManager.Instance);
schedulerThread = new SampleSchedulerThread();
dynamoModel = DynamoModel.Start(
new DynamoModel.StartConfiguration()
{
// See documentation for 'SchedulerIntegrationTests' above.
StartInTestMode = false,
SchedulerThread = schedulerThread
});
}
public override void Cleanup()
{
if (dynamoModel != null)
{
dynamoModel.ShutDown(false);
dynamoModel = null;
}
base.Cleanup();
}
/// <summary>
/// The default constructor.
/// </summary>
public DynamoLogger(DynamoModel dynamoModel, string logDirectory)
{
lock (guardMutex)
{
this.dynamoModel = dynamoModel;
_isDisposed = false;
WarningLevel = WarningLevel.Mild;
Warning = "";
UpdateManager.UpdateManager.Instance.Log += UpdateManager_Log;
StartLogging(logDirectory);
}
}
public void TestShutdownWithDynamoModel01()
{
Assert.IsTrue(schedulerThread.Initialized);
Assert.IsFalse(schedulerThread.Destroyed);
dynamoModel.ShutDown(true); // Shutting down host scenario.
dynamoModel = null; // Nullify so we don't shutdown twice.
Assert.IsTrue(schedulerThread.Initialized);
Assert.IsTrue(schedulerThread.Destroyed);
}
private void Clear(DynamoModel dynamoModel)
{
Pause(this, EventArgs.Empty);
Cleanup();
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(string context, IUpdateManager updateManager, ILogger logger,
IWatchHandler watchHandler, IPreferences preferences)
{
IsCrashing = false;
DynamoLogger = logger;
dynSettings.Controller = this;
Context = context;
//Start heartbeat reporting
InstrumentationLogger.Start();
PreferenceSettings = preferences;
((PreferenceSettings) PreferenceSettings).PropertyChanged += PreferenceSettings_PropertyChanged;
BaseUnit.LengthUnit = PreferenceSettings.LengthUnit;
BaseUnit.AreaUnit = PreferenceSettings.AreaUnit;
BaseUnit.VolumeUnit = PreferenceSettings.VolumeUnit;
BaseUnit.NumberFormat = PreferenceSettings.NumberFormat;
UpdateManager = updateManager;
UpdateManager.UpdateDownloaded += updateManager_UpdateDownloaded;
UpdateManager.ShutdownRequested += updateManager_ShutdownRequested;
UpdateManager.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation),dynSettings.Controller.DynamoLogger, UpdateManager.UpdateDataAvailable));
WatchHandler = watchHandler;
//create the model
DynamoModel = new DynamoModel ();
DynamoModel.AddHomeWorkspace();
DynamoModel.CurrentWorkspace = DynamoModel.HomeSpace;
DynamoModel.CurrentWorkspace.X = 0;
DynamoModel.CurrentWorkspace.Y = 0;
// custom node loader
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginsPath = Path.Combine(directory, "definitions");
CustomNodeManager = new CustomNodeManager(pluginsPath);
SearchViewModel = new SearchViewModel();
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
//This is necessary to avoid a race condition by causing a thread join
//inside the vm exec
//TODO(Luke): Push this into a resync call with the engine controller
ResetEngine();
dynSettings.Controller.DynamoLogger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadNodeModels();
InfoBubbleViewModel = new InfoBubbleViewModel();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
evaluationWorker.DoWork += RunThread;
}
public VisualizationManager(DynamoModel dynamoModel)
{
MaxTesselationDivisions = 128;
this.dynamoModel = dynamoModel;
renderManager = new RenderManager(this, dynamoModel);
//octree = new Octree.OctreeSearch.Octree(10000,-10000,10000,-10000,10000,-10000,10000000);
dynamoModel.WorkspaceClearing += Pause;
dynamoModel.WorkspaceCleared += UnPauseAndUpdate;
dynamoModel.NodeAdded += NodeAdded;
dynamoModel.NodeDeleted += NodeDeleted;
dynamoModel.DeletionStarted += Pause;
dynamoModel.DeletionComplete += UnPauseAndUpdate;
dynamoModel.CleaningUp += Clear;
UnPause(this, EventArgs.Empty);
}
private void Clear(DynamoModel dynamoModel)
{
Pause(this, EventArgs.Empty);
QueueRenderTask();
}
public bool SyncWithWorkspace(DynamoModel dynamoModel, bool addToSearch, bool compileFunction)
{
// Get the internal nodes for the function
var functionWorkspace = WorkspaceModel;
try
{
// Add function defininition
dynamoModel.CustomNodeManager.AddFunctionDefinition(FunctionId, this);
// search
if (addToSearch)
{
AddToSearch(dynamoModel.SearchModel);
}
var info = new CustomNodeInfo(FunctionId, functionWorkspace.Name, functionWorkspace.Category,
functionWorkspace.Description, WorkspaceModel.FileName);
dynamoModel.CustomNodeManager.SetNodeInfo(info);
Compile(dynamoModel, dynamoModel.EngineController);
}
catch (Exception e)
{
dynamoModel.Logger.Log("Error saving:" + e.GetType());
dynamoModel.Logger.Log(e);
return false;
}
return true;
}
/// <summary>
/// Compiles this custom node definition, updating all UI instances to match
/// inputs and outputs and registering new definition with the EngineController.
/// </summary>
public void Compile(DynamoModel dynamoModel, EngineController controller)
{
// If we are loading dyf file, dont compile it until all nodes are loaded
// otherwise some intermediate function defintions will be created.
// TODO: This is a hack, in reality we should be preventing this from being called at the Workspace.RequestSync() level --SJE
if (IsBeingLoaded || IsProxy)
return;
#region Outputs and Inputs and UI updating
#region Find outputs
// Find output elements for the node
List<Output> outputs = WorkspaceModel.Nodes.OfType<Output>().ToList();
var topMost = new List<Tuple<int, NodeModel>>();
List<string> outNames;
// if we found output nodes, add select their inputs
// these will serve as the function output
if (outputs.Any())
{
topMost.AddRange(
outputs.Where(x => x.HasInput(0)).Select(x => Tuple.Create(0, x as NodeModel)));
outNames = outputs.Select(x => x.Symbol).ToList();
}
else
{
outNames = new List<string>();
// if there are no explicitly defined output nodes
// get the top most nodes and set THEM as the output
IEnumerable<NodeModel> topMostNodes = WorkspaceModel.GetTopMostNodes();
var rtnPorts =
//Grab multiple returns from each node
topMostNodes.SelectMany(
topNode =>
//If the node is a recursive instance...
topNode is Function && (topNode as Function).Definition == this
// infinity output
? new[] { new { portIndex = 0, node = topNode, name = "∞" } }
// otherwise, grab all ports with connected outputs and package necessary info
: topNode.OutPortData
.Select(
(port, i) =>
new { portIndex = i, node = topNode, name = port.NickName })
.Where(x => !topNode.HasOutput(x.portIndex)));
foreach (var rtnAndIndex in rtnPorts.Select((rtn, i) => new { rtn, idx = i }))
{
topMost.Add(Tuple.Create(rtnAndIndex.rtn.portIndex, rtnAndIndex.rtn.node));
outNames.Add(rtnAndIndex.rtn.name ?? rtnAndIndex.idx.ToString());
}
}
var nameDict = new Dictionary<string, int>();
foreach (var name in outNames)
{
if (nameDict.ContainsKey(name))
nameDict[name]++;
else
nameDict[name] = 0;
}
nameDict = nameDict.Where(x => x.Value != 0).ToDictionary(x => x.Key, x => x.Value);
outNames.Reverse();
var keys = new List<string>();
foreach (var name in outNames)
{
int amt;
if (nameDict.TryGetValue(name, out amt))
{
nameDict[name] = amt - 1;
keys.Add(name == "" ? amt + ">" : name + amt);
}
else
keys.Add(name);
}
keys.Reverse();
ReturnKeys = keys;
#endregion
//Find function entry point, and then compile
var inputNodes = WorkspaceModel.Nodes.OfType<Symbol>().ToList();
var parameters = inputNodes.Select(x => x.GetAstIdentifierForOutputIndex(0).Value);
Parameters = inputNodes.Select(x => x.InputSymbol);
//Update existing function nodes which point to this function to match its changes
var customNodeInstances = dynamoModel.AllNodes
.OfType<Function>()
.Where(el => el.Definition != null && el.Definition == this);
foreach (var node in customNodeInstances)
node.ResyncWithDefinition();
//Call OnSave for all saved elements
foreach (var node in WorkspaceModel.Nodes)
node.OnSave();
#endregion
var outputNodes = topMost.Select((x) =>
{
var n = x.Item2.GetAstIdentifierForOutputIndex(x.Item1);
return n as AssociativeNode;
});
controller.GenerateGraphSyncDataForCustomNode(
this,
WorkspaceModel.Nodes.Where(x => !(x is Symbol)),
outputNodes,
parameters);
// Not update graph until Run
// if (success)
// controller.UpdateGraph();
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(string context, IUpdateManager updateManager,
IWatchHandler watchHandler, IPreferences preferences, string corePath)
{
DebugSettings = new DebugSettings();
IsCrashing = false;
dynSettings.Controller = this;
Context = context;
PreferenceSettings = preferences;
((PreferenceSettings) PreferenceSettings).PropertyChanged += PreferenceSettings_PropertyChanged;
SIUnit.LengthUnit = PreferenceSettings.LengthUnit;
SIUnit.AreaUnit = PreferenceSettings.AreaUnit;
SIUnit.VolumeUnit = PreferenceSettings.VolumeUnit;
SIUnit.NumberFormat = PreferenceSettings.NumberFormat;
UpdateManager = updateManager;
UpdateManager.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation),dynSettings.DynamoLogger, UpdateManager.UpdateDataAvailable));
WatchHandler = watchHandler;
//Start heartbeat reporting
//This needs to be done after the update manager has been initialised
//so that the version number can be reported
InstrumentationLogger.Start();
//create the model
DynamoModel = new DynamoModel ();
DynamoModel.AddHomeWorkspace();
SearchViewModel = new SearchViewModel(DynamoModel);
DynamoModel.CurrentWorkspace = DynamoModel.HomeSpace;
DynamoModel.CurrentWorkspace.X = 0;
DynamoModel.CurrentWorkspace.Y = 0;
// custom node loader
CustomNodeManager = new CustomNodeManager(DynamoPathManager.Instance.UserDefinitions);
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
EngineController = new EngineController(this);
CustomNodeManager.RecompileAllNodes(EngineController);
//This is necessary to avoid a race condition by causing a thread join
//inside the vm exec
//TODO(Luke): Push this into a resync call with the engine controller
ResetEngine();
dynSettings.DynamoLogger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
Runner = new DynamoRunner();
}
public VisualizationManager(DynamoModel model)
{
dynamoModel = model;
dynamoModel.WorkspaceClearing += Stop;
dynamoModel.WorkspaceCleared += ClearVisualizationsAndRestart;
dynamoModel.WorkspaceAdded += WorkspaceAdded;
dynamoModel.WorkspaceRemoved += WorkspaceRemoved;
dynamoModel.DeletionStarted += Stop;
dynamoModel.DeletionComplete += dynamoModel_DeletionComplete;
dynamoModel.CleaningUp += Clear;
dynamoModel.EvaluationCompleted += RequestAllNodesVisualsUpdate;
dynamoModel.RequestsRedraw += RequestAllNodesVisualsUpdate;
DynamoSelection.Instance.Selection.CollectionChanged += SelectionChanged;
// The initial workspace will have been created before the viz manager
// is created. So we have to hook to that workspace's events during
// construction of the viz manager to make sure we don't miss handling
// events from the pre-existing workspace.
WorkspaceAdded(dynamoModel.CurrentWorkspace);
renderPackageFactory = new HelixRenderPackageFactory();
RenderPackageFactory.TessellationParameters.ShowEdges = model.PreferenceSettings.ShowEdges;
Start();
}
private void CleanupVisualizations(DynamoModel model)
{
CleanupVisualizations();
}
