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