private static void startDynamo()
{
try
{
ExecutingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
smptyTempFolder();
}
DynamoLogger.Instance.StartLogging();
//create a new instance of the ViewModel
controller = new DynamoController(new FSchemeInterop.ExecutionEnvironment(), typeof(DynamoViewModel), Context.NONE);
controller.Testing = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private void StartDynamo()
{
try
{
SIUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
SIUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
SIUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
//create the transaction manager object
TransactionManager.SetupManager(new AutomaticTransactionStrategy());
//tests do not run from idle thread
TransactionManager.Instance.DoAssertInIdleThread = false;
}
public void Start()
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
Controller = DynamoController.MakeSandbox();
//create the view
Ui = new DynamoView();
Ui.DataContext = Controller.DynamoViewModel;
Vm = Controller.DynamoViewModel;
Model = Controller.DynamoModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
EmptyTempFolder();
}
}
protected AbstractMutator(Random rand)
{
this.rand = rand;
this.controller = dynSettings.Controller;
this.dynamoViewModel = controller.DynamoViewModel;
this.dynamoModel = controller.DynamoModel;
}
private void RestartTestSetup()
{
// Shutdown Dynamo and restart it
Ui.Close();
if (Controller != null)
{
Controller.ShutDown(false);
Controller = null;
}
// Setup Temp PreferenceSetting Location for testing
PreferenceSettings.DYNAMO_TEST_PATH = Path.Combine(TempFolder, "UserPreferenceTest.xml");
Controller = DynamoController.MakeSandbox();
DynamoController.IsTestMode = true;
//create the view
Ui = new DynamoView();
Ui.DataContext = Controller.DynamoViewModel;
Vm = Controller.DynamoViewModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
private void StartDynamo()
{
try
{
SIUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
SIUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
SIUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
//create the transaction manager object
TransactionManager.SetupManager(new AutomaticTransactionStrategy());
//tests do not run from idle thread
TransactionManager.Instance.DoAssertInIdleThread = false;
}
private void StartDynamo()
{
try
{
var updater = new RevitServicesUpdater(DynamoRevitApp.ControlledApplication, DynamoRevitApp.Updaters);
updater.ElementAddedForID += ElementMappingCache.GetInstance().WatcherMethodForAdd;
updater.ElementsDeleted += ElementMappingCache.GetInstance().WatcherMethodForDelete;
SIUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
SIUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
SIUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger();
dynSettings.DynamoLogger = logger;
var updateManager = new UpdateManager.UpdateManager(logger);
Controller = DynamoRevit.CreateDynamoRevitControllerAndViewModel(updater, logger, Context.NONE);
DynamoController.IsTestMode = true;
// create the transaction manager object
TransactionManager.SetupManager(new AutomaticTransactionStrategy());
// Because the test framework does not work in the idle thread.
// We need to trick Dynamo into believing that it's in the idle
// thread already.
IdlePromise.InIdleThread = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private void Init(IUpdateManager updateManager)
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
Controller = new DynamoController("None", updateManager,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
//create the view
Ui = new DynamoView {
DataContext = Controller.DynamoViewModel
};
Vm = Controller.DynamoViewModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
DynamoTestUI.EmptyTempFolder(TempFolder);
}
}
protected AbstractMutator(Random rand)
{
this.Rand = rand;
this.Controller = dynSettings.Controller;
this.DynamoViewModel = Controller.DynamoViewModel;
this.DynamoModel = Controller.DynamoModel;
}
public virtual void Start()
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.ResolveAssembly;
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
EmptyTempFolder(TempFolder);
}
// Setup Temp PreferenceSetting Location for testing
PreferenceSettings.DYNAMO_TEST_PATH = Path.Combine(TempFolder, "UserPreferenceTest.xml");
Controller = DynamoController.MakeSandbox();
DynamoController.IsTestMode = true;
//create the view
Ui = new DynamoView();
Ui.DataContext = Controller.DynamoViewModel;
Vm = Controller.DynamoViewModel;
Model = Controller.DynamoModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
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
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
private void StartDynamo()
{
//create a new instance of the ViewModel
Controller = new DynamoController(new ExecutionEnvironment(), typeof (DynamoViewModel), Context.NONE)
{
Testing = true
};
}
protected void StartDynamo()
{
//create a new instance of the ViewModel
Controller = new DynamoController(new ExecutionEnvironment(), typeof (DynamoViewModel), Context.NONE, new UpdateManager.UpdateManager(), new UnitsManager())
{
Testing = true
};
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, ILogger logger, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger, watchHandler, preferences);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
/// <summary>
/// Get a dynFunction from a guid, also stores type internally info for future instantiation.
/// And add the compiled node to the enviro
/// As a side effect, any of its dependent nodes are also initialized.
/// </summary>
/// <param name="environment">The environment from which to get the </param>
/// <param name="guid">Open a definition from a path, without instantiating the nodes or dependents</param>
public bool GetNodeInstance(DynamoController controller, Guid guid, out dynFunction result)
{
if (!this.Contains(guid))
{
result = null;
return(false);
}
FunctionDefinition def = null;
if (!this.IsInitialized(guid))
{
if (!GetDefinitionFromPath(guid, controller, out def))
{
result = null;
return(false);
}
}
else
{
def = this.loadedNodes[guid];
}
dynWorkspaceModel ws = def.Workspace;
IEnumerable <string> inputs =
ws.Nodes.Where(e => e is dynSymbol)
.Select(s => (s as dynSymbol).Symbol);
IEnumerable <string> outputs =
ws.Nodes.Where(e => e is dynOutput)
.Select(o => (o as dynOutput).Symbol);
if (!outputs.Any())
{
var topMost = new List <Tuple <int, dynNodeModel> >();
IEnumerable <dynNodeModel> topMostNodes = ws.GetTopMostNodes();
foreach (dynNodeModel topNode in topMostNodes)
{
foreach (int output in Enumerable.Range(0, topNode.OutPortData.Count))
{
if (!topNode.HasOutput(output))
{
topMost.Add(Tuple.Create(output, topNode));
}
}
}
outputs = topMost.Select(x => x.Item2.OutPortData[x.Item1].NickName);
}
result = controller.DynamoViewModel.CreateFunction(inputs, outputs, def);
result.NickName = ws.Name;
return(true);
}
/// <summary>
/// The class constructor.
/// </summary>
/// <param name="controller"> Reference to to the DynamoController object for the app </param>
public PackageManagerClient(DynamoController controller)
{
Controller = controller;
LoadedPackageHeaders = new Dictionary<FunctionDefinition, PackageHeader>();
Client = new Client("https://accounts-dev.autodesk.com", "http://54.243.225.192:8080");
Worker = new BackgroundWorker();
IsLoggedIn = false;
}
/// <summary>
/// Get a guid from the name of a node. If it doesn't exist, returns Guid.Empty.
/// </summary>
/// <param name="guid">Open a definition from a path, without instantiating the nodes or dependents</param>
public bool GetNodeInstance(DynamoController controller, string name, out Function result)
{
if (!this.Contains(name))
{
result = null;
return(false);
}
return(this.GetNodeInstance(GetGuidFromName(name), out result));
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
var corePath =
Path.GetFullPath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences, corePath);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
protected void StartDynamo()
{
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
////create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
protected void StartDynamo()
{
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
////create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
public void Regressions(RegressionTestData testData)
{
Exception exception = null;
try
{
var dynamoFilePath = testData.Arguments[0].ToString();
var revitFilePath = testData.Arguments[1].ToString();
Setup();
//ensure that the incoming arguments are not empty or null
//if a dyn file is found in the regression tests directory
//and there is no corresponding rfa or rvt, then an empty string
//or a null will be passed into here.
Assert.IsNotNullOrEmpty(dynamoFilePath, "Dynamo file path is invalid or missing.");
Assert.IsNotNullOrEmpty(revitFilePath, "Revit file path is invalid or missing.");
//open the revit model
SwapCurrentModel(revitFilePath);
var model = Controller.DynamoModel;
//open the dyn file
model.Open(dynamoFilePath);
//run the expression and assert that it does not
//throw an error
Assert.DoesNotThrow(() => dynSettings.Controller.RunExpression());
var errorNodes =
dynSettings.Controller.DynamoModel.Nodes.Where(
x => x.State == ElementState.Error || x.State == ElementState.Warning);
Assert.AreEqual(0, errorNodes.Count());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
Controller.ShutDown(false);
Controller = null;
Teardown();
}
if (exception != null)
{
Assert.Fail(exception.Message);
}
}
private void StartDynamo()
{
try
{
//create a new instance of the ViewModel
Controller = new DynamoController(new ExecutionEnvironment(), typeof(DynamoViewModel), Context.NONE)
{
Testing = true
};
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private void StartDynamo()
{
try
{
//create a new instance of the ViewModel
Controller = new DynamoController(new ExecutionEnvironment(), typeof(DynamoViewModel), Context.NONE)
{
Testing = true
};
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
public static Application MakeSandboxAndRun(string commandFilePath)
{
var controller = DynamoController.MakeSandbox(commandFilePath);
var app = new Application();
//create the view
var ui = new DynamoView();
ui.DataContext = controller.DynamoViewModel;
controller.UIDispatcher = ui.Dispatcher;
app.Run(ui);
return(app);
}
public void Regressions(RegressionTestData testData)
{
Exception exception = null;
try
{
var dynamoFilePath = testData.Arguments[0].ToString();
var revitFilePath = testData.Arguments[1].ToString();
Setup();
//ensure that the incoming arguments are not empty or null
//if a dyn file is found in the regression tests directory
//and there is no corresponding rfa or rvt, then an empty string
//or a null will be passed into here.
Assert.IsNotNullOrEmpty(dynamoFilePath, "Dynamo file path is invalid or missing.");
Assert.IsNotNullOrEmpty(revitFilePath, "Revit file path is invalid or missing.");
//open the revit model
SwapCurrentModel(revitFilePath);
//open the dyn file
Controller.DynamoViewModel.OpenCommand.Execute(dynamoFilePath);
//run the expression and assert that it does not
//throw an error
Assert.DoesNotThrow(() => dynSettings.Controller.RunExpression());
var errorNodes =
dynSettings.Controller.DynamoModel.Nodes.Where(
x => x.State == ElementState.Error || x.State == ElementState.Warning);
Assert.AreEqual(0, errorNodes.Count());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
Controller.ShutDown(false);
Controller = null;
Teardown();
}
if (exception != null)
{
Assert.Fail(exception.Message);
}
}
public static Application MakeSandboxAndRun(string commandFilePath, bool turnOnServer)
{
var controller = DynamoController.MakeSandbox(commandFilePath);
var app = new Application();
//create the view
var ui = new DynamoView();
ui.DataContext = controller.DynamoViewModel;
controller.UIDispatcher = ui.Dispatcher;
if (turnOnServer)
{
var webSocketServer = new WebServer();
webSocketServer.Start();
webSocketServer.ReceivedMessage += new MessageEventHandler(dynSettings.Controller.DynamoViewModel.ExecuteMessageFromSocket);
webSocketServer.Info += (infoMessage) =>
{
if (dynSettings.DynamoLogger != null)
{
dynSettings.DynamoLogger.Log(infoMessage);
}
};
webSocketServer.Error += (errorMessage) =>
{
if (dynSettings.DynamoLogger != null)
{
dynSettings.DynamoLogger.LogError(errorMessage);
}
};
dynSettings.Controller.RequestComputationCompleted += (nodes) =>
{
// TODO: Send nodes instead of nodes GUIDs
List <Guid> guidsList = nodes.Select(nodeModel => nodeModel.GUID).ToList();
webSocketServer.SendResponse(new ComputationResponse()
{
Status = ResponceStatuses.Success,
Nodes = guidsList.ToArray()
}, dynSettings.Controller.SessionId);
};
}
app.Run(ui);
return(app);
}
public EngineController(DynamoController controller)
{
libraryServices = LibraryServices.GetInstance();
libraryServices.LibraryLoading += this.LibraryLoading;
libraryServices.LibraryLoadFailed += this.LibraryLoadFailed;
libraryServices.LibraryLoaded += this.LibraryLoaded;
liveRunnerServices = new LiveRunnerServices(this);
liveRunnerServices.ReloadAllLibraries(libraryServices.Libraries.ToList());
astBuilder = new AstBuilder(this);
syncDataManager = new SyncDataManager();
this.controller = controller;
this.controller.DynamoModel.NodeDeleted += NodeDeleted;
}
public DynamoRevitViewModel(DynamoController controller) : base(controller)
{
Predicate <dynNodeModel> requiresTransactionPredicate = delegate(dynNodeModel node)
{
return(node is dynRevitTransactionNode);
};
checkRequiresTransaction = new PredicateTraverser(requiresTransactionPredicate);
Predicate <dynNodeModel> manualTransactionPredicate = delegate(dynNodeModel node)
{
return(node is dynTransaction);
};
checkManualTransaction = new PredicateTraverser(manualTransactionPredicate);
}
public DynamoRevitViewModel(DynamoController controller)
: base(controller)
{
Predicate<dynNodeModel> requiresTransactionPredicate = delegate(dynNodeModel node)
{
return node is dynRevitTransactionNode;
};
checkRequiresTransaction = new PredicateTraverser(requiresTransactionPredicate);
Predicate<dynNodeModel> manualTransactionPredicate = delegate(dynNodeModel node)
{
return node is dynTransaction;
};
checkManualTransaction = new PredicateTraverser(manualTransactionPredicate);
}
public override void Cleanup()
{
try
{
Controller.ShutDown(false);
this.Controller = null;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
base.Cleanup();
GC.Collect();
}
public override void Cleanup()
{
try
{
Controller.ShutDown(false, null);
this.Controller = null;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
base.Cleanup();
GC.Collect();
}
protected void StartDynamo()
{
var logger = new DynamoLogger();
dynSettings.DynamoLogger = logger;
var updateManager = new UpdateManager.UpdateManager(logger);
var corePath =
Path.GetFullPath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
////create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager,
new DefaultWatchHandler(), new PreferenceSettings(), corePath);
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
protected void StartDynamo()
{
var corePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
DynamoPathManager.Instance.InitializeCore(corePath);
var logger = new DynamoLogger(DynamoPathManager.Instance.Logs);
dynSettings.DynamoLogger = logger;
var updateManager = new UpdateManager.UpdateManager(logger);
////create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager,
new DefaultWatchHandler(), new PreferenceSettings(), corePath);
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
}
private void RecordSelectionForUndo()
{
// This is where we attempt to store all the models in undo recorder
// before they are modified (i.e. being dragged around the canvas).
// Note that we only do this once when the first mouse-move occurs
// after a mouse-down, because mouse-down can potentially be used
// just to select a node (as opposed to moving the selected nodes), in
// which case we don't want any of the nodes to be recorded for undo.
//
List <ModelBase> models = DynamoSelection.Instance.Selection.
Where((x) => (x is ModelBase)).Cast <ModelBase>().ToList <ModelBase>();
this._model.RecordModelsForModification(models);
DynamoController controller = Dynamo.Utilities.dynSettings.Controller;
controller.DynamoViewModel.UndoCommand.RaiseCanExecuteChanged();
controller.DynamoViewModel.RedoCommand.RaiseCanExecuteChanged();
}
public EngineController(DynamoController controller)
{
libraryServices = LibraryServices.GetInstance();
libraryServices.LibraryLoading += this.LibraryLoading;
libraryServices.LibraryLoadFailed += this.LibraryLoadFailed;
libraryServices.LibraryLoaded += this.LibraryLoaded;
liveRunnerServices = new LiveRunnerServices(this);
liveRunnerServices.ReloadAllLibraries(libraryServices.Libraries.ToList());
astBuilder = new AstBuilder(this);
syncDataManager = new SyncDataManager();
this.controller = controller;
this.controller.DynamoModel.NodeDeleted += NodeDeleted;
this.controller.CustomNodeManager.RecompileAllNodes(this);
}
private void StartDynamo()
{
try
{
var units = new UnitsManager
{
HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot,
HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot,
HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot
};
//create a new instance of the ViewModel
Controller = new DynamoController(new ExecutionEnvironment(), typeof(DynamoViewModel), Context.NONE, new UpdateManager.UpdateManager(), units, new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private void RunCommandsFromFile(string commandFileName)
{
string commandFilePath = DynamoTestUI.GetTestDirectory();
commandFilePath = Path.Combine(commandFilePath, @"core\recorded\");
commandFilePath = Path.Combine(commandFilePath, commandFileName);
// Create the controller to run alongside the view.
controller = DynamoController.MakeSandbox(commandFilePath);
// Create the view.
var dynamoView = new DynamoView();
dynamoView.DataContext = controller.DynamoViewModel;
controller.UIDispatcher = dynamoView.Dispatcher;
dynamoView.ShowDialog();
Assert.IsNotNull(controller);
Assert.IsNotNull(controller.DynamoModel);
Assert.IsNotNull(controller.DynamoModel.CurrentWorkspace);
workspace = controller.DynamoModel.CurrentWorkspace;
}
public static void Main(string[] args)
{
//DynamoLogger.Instance.StartLogging();
try
{
var controller = new DynamoController(new Dynamo.FSchemeInterop.ExecutionEnvironment(), typeof(DynamoViewModel), Context.NONE);
//create the view
dynSettings.Bench = new DynamoView();
dynSettings.Bench.DataContext = controller.DynamoViewModel;
controller.UIDispatcher = dynSettings.Bench.Dispatcher;
var app = new Application();
app.Run(dynSettings.Bench);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
}
}
protected void RunCommandsFromFile(string commandFileName,
bool autoRun = false, CommandCallback commandCallback = null)
{
string commandFilePath = DynamoTestUI.GetTestDirectory(ExecutingDirectory);
commandFilePath = Path.Combine(commandFilePath, @"core\recorded\");
commandFilePath = Path.Combine(commandFilePath, commandFileName);
if (this.Controller != null)
{
var message = "Multiple DynamoController detected!";
throw new InvalidOperationException(message);
}
// Create the controller to run alongside the view.
this.Controller = DynamoController.MakeSandbox(commandFilePath);
var controller = this.Controller;
controller.DynamoViewModel.DynamicRunEnabled = autoRun;
DynamoController.IsTestMode = true;
RegisterCommandCallback(commandCallback);
// Create the view.
var dynamoView = new DynamoView();
dynamoView.DataContext = controller.DynamoViewModel;
controller.UIDispatcher = dynamoView.Dispatcher;
dynamoView.ShowDialog();
Assert.IsNotNull(controller);
Assert.IsNotNull(controller.DynamoModel);
Assert.IsNotNull(controller.DynamoModel.CurrentWorkspace);
workspace = controller.DynamoModel.CurrentWorkspace;
workspaceViewModel = controller.DynamoViewModel.CurrentSpaceViewModel;
}
private void StartDynamo()
{
try
{
var updater = new RevitServicesUpdater(DynamoRevitApp.ControlledApplication, DynamoRevitApp.Updaters);
updater.ElementAddedForID += ElementMappingCache.GetInstance().WatcherMethodForAdd;
updater.ElementsDeleted += ElementMappingCache.GetInstance().WatcherMethodForDelete;
SIUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
SIUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
SIUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger(DynamoPathManager.Instance.Logs);
dynSettings.DynamoLogger = logger;
var updateManager = new UpdateManager.UpdateManager(logger);
Controller = DynamoRevit.CreateDynamoRevitControllerAndViewModel(updater, logger, Context.NONE);
DynamoController.IsTestMode = true;
// create the transaction manager object
TransactionManager.SetupManager(new AutomaticTransactionStrategy());
// Because the test framework does not work in the idle thread.
// We need to trick Dynamo into believing that it's in the idle
// thread already.
IdlePromise.InIdleThread = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
protected void StartDynamo()
{
////create a new instance of the ViewModel
Controller = new DynamoController(typeof(DynamoViewModel), Context.NONE, new UpdateManager.UpdateManager(), new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
}
private void StartDynamo()
{
try
{
SIUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
SIUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
SIUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
//create a new instance of the ViewModel
Controller = new DynamoController(typeof (DynamoViewModel), Context.NONE, new UpdateManager.UpdateManager(), new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private static void StartDynamo()
{
try
{
string tempPath = Path.GetTempPath();
var random = new Random();
string logPath = Path.Combine(tempPath, "dynamoLog" + random.Next() + ".txt");
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
EmptyTempFolder();
}
TextWriter tw = new StreamWriter(logPath);
tw.WriteLine("Dynamo log started " + DateTime.Now.ToString());
dynSettings.Writer = tw;
//create a new instance of the ViewModel
var controller = new DynamoController(new FSchemeInterop.ExecutionEnvironment());
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
public MutatorDriver(DynamoController dynamoController)
{
this.dynamoController = dynamoController;
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
RevThread.IdlePromise.RegisterIdle(revit.Application);
if (revit.JournalData != null && revit.JournalData.ContainsKey("debug"))
{
if (bool.Parse(revit.JournalData["debug"]))
Debugger.Launch();
}
AppDomain.CurrentDomain.AssemblyResolve +=
Analyze.Render.AssemblyHelper.ResolveAssemblies;
//Add an assembly load step for the System.Windows.Interactivity assembly
//Revit owns a version of this as well. Adding our step here prevents a duplicative
//load of the dll at a later time.
string interactivityPath = Path.Combine(
DynamoPathManager.Instance.MainExecPath,
"System.Windows.Interactivity.dll");
if (File.Exists(interactivityPath))
Assembly.LoadFrom(interactivityPath);
try
{
#region default level
var fecLevel =
new FilteredElementCollector(revit.Application.ActiveUIDocument.Document);
fecLevel.OfClass(typeof(Level));
var defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
var logger = new DynamoLogger(DynamoPathManager.Instance.Logs);
dynSettings.DynamoLogger = logger;
if (DocumentManager.Instance.CurrentUIApplication == null)
DocumentManager.Instance.CurrentUIApplication = revit.Application;
DocumentManager.OnLogError += dynSettings.DynamoLogger.Log;
dynRevitSettings.DefaultLevel = defaultLevel;
//TODO: has to be changed when we handle multiple docs
Updater = new RevitServicesUpdater(
DynamoRevitApp.ControlledApplication,
DynamoRevitApp.Updaters);
Updater.ElementAddedForID += ElementMappingCache.GetInstance().WatcherMethodForAdd;
Updater.ElementsDeleted += ElementMappingCache.GetInstance().WatcherMethodForDelete;
RevThread.IdlePromise.ExecuteOnIdleAsync(
delegate
{
//get window handle
IntPtr mwHandle = Process.GetCurrentProcess().MainWindowHandle;
var r = new Regex(@"\b(Autodesk |Structure |MEP |Architecture )\b");
string context = r.Replace(revit.Application.Application.VersionName, "");
//they changed the application version name conventions for vasari
//it no longer has a version year so we can't compare it to other versions
//TODO:come up with a more stable way to test for Vasari beta 3
if (context == "Vasari")
context = "Vasari 2014";
dynamoController = CreateDynamoRevitControllerAndViewModel(
Updater,
logger,
context);
var dynamoView = new DynamoView
{
DataContext = dynamoController.DynamoViewModel
};
dynamoController.UIDispatcher = dynamoView.Dispatcher;
//set window handle and show dynamo
new WindowInteropHelper(dynamoView).Owner = mwHandle;
handledCrash = false;
dynamoView.Show();
if (revit.JournalData != null && revit.JournalData.ContainsKey("dynPath"))
dynamoController.DynamoModel.OpenWorkspace(revit.JournalData["dynPath"]);
dynamoView.Dispatcher.UnhandledException += DispatcherOnUnhandledException;
dynamoView.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
revit.Application.ViewActivating += Application_ViewActivating;
});
// Disable the Dynamo button to prevent a re-run
DynamoRevitApp.DynamoButton.Enabled = false;
}
catch (Exception ex)
{
InstrumentationLogger.LogException(ex);
StabilityTracking.GetInstance().NotifyCrash();
//isRunning = false;
MessageBox.Show(ex.ToString());
dynSettings.DynamoLogger.LogError(ex.Message);
dynSettings.DynamoLogger.LogError(ex.StackTrace);
dynSettings.DynamoLogger.LogError("Dynamo log ended " + DateTime.Now);
DynamoRevitApp.DynamoButton.Enabled = true;
return Result.Failed;
}
return Result.Succeeded;
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
AppDomain.CurrentDomain.AssemblyResolve += Dynamo.Utilities.AssemblyHelper.CurrentDomain_AssemblyResolve;
AppDomain.CurrentDomain.AssemblyResolve += DynamoRaaS.AssemblyHelper.ResolveAssemblies;
//Add an assembly load step for the System.Windows.Interactivity assembly
//Revit owns a version of this as well. Adding our step here prevents a duplicative
//load of the dll at a later time.
var assLoc = Assembly.GetExecutingAssembly().Location;
var interactivityPath = Path.Combine(Path.GetDirectoryName(assLoc), "System.Windows.Interactivity.dll");
var interactivityAss = Assembly.LoadFrom(interactivityPath);
//When a user double-clicks the Dynamo icon, we need to make
//sure that we don't create another instance of Dynamo.
if (isRunning)
{
Debug.WriteLine("Dynamo is already running.");
if (dynamoView != null)
{
dynamoView.Focus();
}
return(Result.Succeeded);
}
isRunning = true;
try
{
m_revit = revit.Application;
m_doc = m_revit.ActiveUIDocument;
#region default level
Level defaultLevel = null;
var fecLevel = new FilteredElementCollector(m_doc.Document);
fecLevel.OfClass(typeof(Level));
defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
dynRevitSettings.Revit = m_revit;
dynRevitSettings.Doc = m_doc;
dynRevitSettings.DefaultLevel = defaultLevel;
IdlePromise.ExecuteOnIdle(delegate
{
//get window handle
IntPtr mwHandle = Process.GetCurrentProcess().MainWindowHandle;
Regex r = new Regex(@"\b(Autodesk |Structure |MEP |Architecture )\b");
string context = r.Replace(m_revit.Application.VersionName, "");
//they changed the application version name conventions for vasari
//it no longer has a version year so we can't compare it to other versions
//TODO:come up with a more stable way to test for Vasari beta 3
if (context == "Vasari")
{
context = "Vasari 2014";
}
var units = new UnitsManager
{
HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot,
HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot,
HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot
};
dynamoController = new DynamoController_Revit(DynamoRevitApp.env, DynamoRevitApp.Updater, typeof(DynamoRevitViewModel), context, units);
dynamoView = new DynamoView {
DataContext = dynamoController.DynamoViewModel
};
dynamoController.UIDispatcher = dynamoView.Dispatcher;
//set window handle and show dynamo
new WindowInteropHelper(dynamoView).Owner = mwHandle;
handledCrash = false;
dynamoView.WindowStartupLocation = WindowStartupLocation.Manual;
Rectangle bounds = Screen.PrimaryScreen.Bounds;
dynamoView.Left = dynamoViewX ?? bounds.X;
dynamoView.Top = dynamoViewY ?? bounds.Y;
dynamoView.Width = dynamoViewWidth ?? 1000.0;
dynamoView.Height = dynamoViewHeight ?? 800.0;
dynamoView.Show();
dynamoView.Dispatcher.UnhandledException -= DispatcherOnUnhandledException;
dynamoView.Dispatcher.UnhandledException += DispatcherOnUnhandledException;
dynamoView.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
//revit.Application.ViewActivated += new EventHandler<Autodesk.Revit.UI.Events.ViewActivatedEventArgs>(Application_ViewActivated);
revit.Application.ViewActivating += Application_ViewActivating;
});
}
catch (Exception ex)
{
isRunning = false;
MessageBox.Show(ex.ToString());
DynamoLogger.Instance.Log(ex.Message);
DynamoLogger.Instance.Log(ex.StackTrace);
DynamoLogger.Instance.Log("Dynamo log ended " + DateTime.Now.ToString());
return(Result.Failed);
}
return(Result.Succeeded);
}
/// <summary>
/// Deserialize a function definition from a given path. A side effect of this function is that
/// the node is added to the dictionary of loadedNodes.
/// </summary>
/// <param name="funcDefGuid">The function guid we're currently loading</param>
/// <param name="controller">Reference to the calling controller</param>
/// <param name="def">The resultant function definition</param>
/// <returns></returns>
private bool GetDefinitionFromPath(Guid funcDefGuid, DynamoController controller, out FunctionDefinition def)
{
try
{
var xmlPath = GetNodePath(funcDefGuid);
#region read xml file
var xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
string funName = null;
string category = "";
double cx = dynBench.CANVAS_OFFSET_X;
double cy = dynBench.CANVAS_OFFSET_Y;
string id = "";
// load the header
foreach (XmlNode node in xmlDoc.GetElementsByTagName("dynWorkspace"))
{
foreach (XmlAttribute att in node.Attributes)
{
if (att.Name.Equals("X"))
cx = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Y"))
cy = Convert.ToDouble(att.Value);
else if (att.Name.Equals("Name"))
funName = att.Value;
else if (att.Name.Equals("Category"))
category = att.Value;
else if (att.Name.Equals("ID"))
{
id = att.Value;
}
}
}
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName))
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
#endregion
//If there is no function name, then we are opening a home definition
if (funName == null)
{
//View the home workspace, then open the bench file
if (!controller.ViewingHomespace)
controller.ViewHomeWorkspace(); //TODO: Refactor
def = null;
return controller.OpenWorkbench(xmlPath);
}
dynSettings.Bench.Log("Loading node definition for \"" + funName + "\" from: " + xmlPath);
var workSpace = new FuncWorkspace(
funName, category.Length > 0
? category
: BuiltinNodeCategories.MISC, cx, cy);
def = new FunctionDefinition(Guid.Parse(id))
{
Workspace = workSpace
};
// load a dummy version, so any nodes depending on this node
// will find an (empty) identifier on compilation
FScheme.Expression dummyExpression = FScheme.Expression.NewNumber_E(5);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), dummyExpression);
this.loadedNodes.Add(def.FunctionId, def);
dynWorkspace ws = def.Workspace;
//this.Log("Opening definition " + xmlPath + "...");
XmlNodeList elNodes = xmlDoc.GetElementsByTagName("dynElements");
XmlNodeList cNodes = xmlDoc.GetElementsByTagName("dynConnectors");
XmlNodeList nNodes = xmlDoc.GetElementsByTagName("dynNotes");
XmlNode elNodesList = elNodes[0];
XmlNode cNodesList = cNodes[0];
XmlNode nNodesList = nNodes[0];
#region instantiate nodes
foreach (XmlNode elNode in elNodesList.ChildNodes)
{
XmlAttribute typeAttrib = elNode.Attributes[0];
XmlAttribute guidAttrib = elNode.Attributes[1];
XmlAttribute nicknameAttrib = elNode.Attributes[2];
XmlAttribute xAttrib = elNode.Attributes[3];
XmlAttribute yAttrib = elNode.Attributes[4];
string typeName = typeAttrib.Value;
string oldNamespace = "Dynamo.Elements.";
if (typeName.StartsWith(oldNamespace))
typeName = "Dynamo.Nodes." + typeName.Remove(0, oldNamespace.Length);
//test the GUID to confirm that it is non-zero
//if it is zero, then we have to fix it
//this will break the connectors, but it won't keep
//propagating bad GUIDs
var guid = new Guid(guidAttrib.Value);
if (guid == Guid.Empty)
{
guid = Guid.NewGuid();
}
string nickname = nicknameAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//Type t = Type.GetType(typeName);
TypeLoadData tData;
Type t;
if (!controller.builtinTypesByTypeName.TryGetValue(typeName, out tData))
{
t = Type.GetType(typeName);
if (t == null)
{
dynSettings.Bench.Log("Error loading definition. Could not load node of type: " + typeName);
return false;
}
}
else
t = tData.Type;
var el = controller.CreateInstanceAndAddNodeToWorkspace(t, nickname, guid, x, y, ws, Visibility.Hidden);
if (el == null)
return false;
el.DisableReporting();
el.LoadElement(elNode); // inject the node properties from the xml
// it has no
if (el is dynFunction)
{
var fun = el as dynFunction;
// we've found a custom node, we need to attempt to load its guid.
// if it doesn't exist (i.e. its a legacy node), we need to assign it one,
// deterministically
Guid funId;
try
{
funId = Guid.Parse(fun.Symbol);
}
catch
{
funId = GuidUtility.Create(GuidUtility.UrlNamespace, nicknameAttrib.Value);
fun.Symbol = funId.ToString();
}
// if it's not a recurisve node and it's not yet loaded, load it
if (funcDefGuid != funId && !this.loadedNodes.ContainsKey(funId))
{
dynSettings.Controller.CustomNodeLoader.GetFunctionDefinition(funId);
fun.Definition = this.loadedNodes[funId];
}
else if ( this.loadedNodes.ContainsKey(funId ))
{
fun.Definition = this.loadedNodes[funId];
}
}
}
#endregion
dynSettings.Bench.WorkBench.UpdateLayout();
#region instantiate connectors
foreach (XmlNode connector in cNodesList.ChildNodes)
{
XmlAttribute guidStartAttrib = connector.Attributes[0];
XmlAttribute intStartAttrib = connector.Attributes[1];
XmlAttribute guidEndAttrib = connector.Attributes[2];
XmlAttribute intEndAttrib = connector.Attributes[3];
XmlAttribute portTypeAttrib = connector.Attributes[4];
var guidStart = new Guid(guidStartAttrib.Value);
var guidEnd = new Guid(guidEndAttrib.Value);
int startIndex = Convert.ToInt16(intStartAttrib.Value);
int endIndex = Convert.ToInt16(intEndAttrib.Value);
int portType = Convert.ToInt16(portTypeAttrib.Value);
//find the elements to connect
dynNode start = null;
dynNode end = null;
foreach (dynNode e in ws.Nodes)
{
if (e.NodeUI.GUID == guidStart)
{
start = e;
}
else if (e.NodeUI.GUID == guidEnd)
{
end = e;
}
if (start != null && end != null)
{
break;
}
}
//don't connect if the end element is an instance map
//those have a morphing set of inputs
//dynInstanceParameterMap endTest = end as dynInstanceParameterMap;
//if (endTest != null)
//{
// continue;
//}
try
{
if (start != null && end != null && start != end)
{
var newConnector = new dynConnector(
start.NodeUI, end.NodeUI,
startIndex, endIndex,
portType, false
);
ws.Connectors.Add(newConnector);
}
}
catch
{
dynSettings.Bench.Log(string.Format("ERROR : Could not create connector between {0} and {1}.", start.NodeUI.GUID, end.NodeUI.GUID));
}
}
#endregion
#region instantiate notes
if (nNodesList != null)
{
foreach (XmlNode note in nNodesList.ChildNodes)
{
XmlAttribute textAttrib = note.Attributes[0];
XmlAttribute xAttrib = note.Attributes[1];
XmlAttribute yAttrib = note.Attributes[2];
string text = textAttrib.Value;
double x = Convert.ToDouble(xAttrib.Value);
double y = Convert.ToDouble(yAttrib.Value);
//dynNote n = Bench.AddNote(text, x, y, ws);
//Bench.AddNote(text, x, y, ws);
var paramDict = new Dictionary<string, object>();
paramDict.Add("x", x);
paramDict.Add("y", y);
paramDict.Add("text", text);
paramDict.Add("workspace", ws);
DynamoCommands.AddNoteCmd.Execute(paramDict);
}
}
#endregion
foreach (dynNode e in ws.Nodes)
e.EnableReporting();
DynamoController.hideWorkspace(ws);
ws.FilePath = xmlPath;
controller.PackageManagerClient.LoadPackageHeader(def, funName);
var expression = CompileFunction(def);
controller.FSchemeEnvironment.DefineSymbol(def.FunctionId.ToString(), expression);
}
catch (Exception ex)
{
dynSettings.Bench.Log("There was an error opening the workbench.");
dynSettings.Bench.Log(ex);
controller.CleanWorkbench();
def = null;
return false;
}
return true;
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
AppDomain.CurrentDomain.AssemblyResolve += Dynamo.Utilities.AssemblyHelper.CurrentDomain_AssemblyResolve;
AppDomain.CurrentDomain.AssemblyResolve += DynamoRaaS.AssemblyHelper.ResolveAssemblies;
//Add an assembly load step for the System.Windows.Interactivity assembly
//Revit owns a version of this as well. Adding our step here prevents a duplicative
//load of the dll at a later time.
var assLoc = Assembly.GetExecutingAssembly().Location;
var interactivityPath = Path.Combine(Path.GetDirectoryName(assLoc), "System.Windows.Interactivity.dll");
var interactivityAss = Assembly.LoadFrom(interactivityPath);
//When a user double-clicks the Dynamo icon, we need to make
//sure that we don't create another instance of Dynamo.
if (isRunning)
{
Debug.WriteLine("Dynamo is already running.");
if (dynamoView != null)
{
dynamoView.Focus();
}
return Result.Succeeded;
}
isRunning = true;
try
{
m_revit = revit.Application;
m_doc = m_revit.ActiveUIDocument;
#region default level
Level defaultLevel = null;
var fecLevel = new FilteredElementCollector(m_doc.Document);
fecLevel.OfClass(typeof (Level));
defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
dynRevitSettings.Revit = m_revit;
dynRevitSettings.Doc = m_doc;
dynRevitSettings.DefaultLevel = defaultLevel;
IdlePromise.ExecuteOnIdle(delegate
{
//get window handle
IntPtr mwHandle = Process.GetCurrentProcess().MainWindowHandle;
Regex r = new Regex(@"\b(Autodesk |Structure |MEP |Architecture )\b");
string context = r.Replace(m_revit.Application.VersionName, "");
//they changed the application version name conventions for vasari
//it no longer has a version year so we can't compare it to other versions
//TODO:come up with a more stable way to test for Vasari beta 3
if (context == "Vasari")
context = "Vasari 2014";
var units = new UnitsManager
{
HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot,
HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot,
HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot
};
dynamoController = new DynamoController_Revit(DynamoRevitApp.env, DynamoRevitApp.Updater, typeof(DynamoRevitViewModel), context, units);
dynamoView = new DynamoView { DataContext = dynamoController.DynamoViewModel };
dynamoController.UIDispatcher = dynamoView.Dispatcher;
//set window handle and show dynamo
new WindowInteropHelper(dynamoView).Owner = mwHandle;
handledCrash = false;
dynamoView.WindowStartupLocation = WindowStartupLocation.Manual;
Rectangle bounds = Screen.PrimaryScreen.Bounds;
dynamoView.Left = dynamoViewX ?? bounds.X;
dynamoView.Top = dynamoViewY ?? bounds.Y;
dynamoView.Width = dynamoViewWidth ?? 1000.0;
dynamoView.Height = dynamoViewHeight ?? 800.0;
dynamoView.Show();
dynamoView.Dispatcher.UnhandledException -= DispatcherOnUnhandledException;
dynamoView.Dispatcher.UnhandledException += DispatcherOnUnhandledException;
dynamoView.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
//revit.Application.ViewActivated += new EventHandler<Autodesk.Revit.UI.Events.ViewActivatedEventArgs>(Application_ViewActivated);
revit.Application.ViewActivating += Application_ViewActivating;
});
}
catch (Exception ex)
{
isRunning = false;
MessageBox.Show(ex.ToString());
DynamoLogger.Instance.Log(ex.Message);
DynamoLogger.Instance.Log(ex.StackTrace);
DynamoLogger.Instance.Log("Dynamo log ended " + DateTime.Now.ToString());
return Result.Failed;
}
return Result.Succeeded;
}
/// <summary>
/// Get a dynFunction from a guid, also stores type internally info for future instantiation.
/// And add the compiled node to the enviro
/// As a side effect, any of its dependent nodes are also initialized.
/// </summary>
/// <param name="environment">The environment from which to get the </param>
/// <param name="guid">Open a definition from a path, without instantiating the nodes or dependents</param>
public bool GetNodeInstance(DynamoController controller, Guid guid, out dynFunction result)
{
if ( !this.Contains(guid) ) {
result = null;
return false;
}
FunctionDefinition def = null;
if (!this.IsInitialized(guid))
{
if (!GetDefinitionFromPath(guid, controller, out def))
{
result = null;
return false;
}
} else {
def = this.loadedNodes[guid];
}
dynWorkspace ws = def.Workspace;
//TODO: Update to base off of Definition
IEnumerable<string> inputs =
ws.Nodes.Where(e => e is dynSymbol)
.Select(s => (s as dynSymbol).Symbol);
IEnumerable<string> outputs =
ws.Nodes.Where(e => e is dynOutput)
.Select(o => (o as dynOutput).Symbol);
if (!outputs.Any())
{
var topMost = new List<Tuple<int, dynNode>>();
IEnumerable<dynNode> topMostNodes = ws.GetTopMostNodes();
foreach (dynNode topNode in topMostNodes)
{
foreach (int output in Enumerable.Range(0, topNode.OutPortData.Count))
{
if (!topNode.HasOutput(output))
topMost.Add(Tuple.Create(output, topNode));
}
}
outputs = topMost.Select(x => x.Item2.OutPortData[x.Item1].NickName);
}
result = new dynFunction(inputs, outputs, def);
result.NodeUI.NickName = ws.Name;
return true;
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
//When a user double-clicks the Dynamo icon, we need to make
//sure that we don't create another instance of Dynamo.
if (isRunning)
{
Debug.WriteLine("Dynamo is already running.");
if (dynamoView != null)
{
dynamoView.Focus();
}
return(Result.Succeeded);
}
isRunning = true;
DynamoLogger.Instance.StartLogging();
try
{
m_revit = revit.Application;
m_doc = m_revit.ActiveUIDocument;
#region default level
Level defaultLevel = null;
var fecLevel = new FilteredElementCollector(m_doc.Document);
fecLevel.OfClass(typeof(Level));
defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
dynRevitSettings.Revit = m_revit;
dynRevitSettings.Doc = m_doc;
dynRevitSettings.DefaultLevel = defaultLevel;
IdlePromise.ExecuteOnIdle(delegate
{
//get window handle
IntPtr mwHandle = Process.GetCurrentProcess().MainWindowHandle;
//show the window
Regex r = new Regex(@"\b(Autodesk |Structure |MEP |Architecture )\b");
string context = r.Replace(m_revit.Application.VersionName, "");
//they changed the application version name conventions for vasari
//it no longer has a version year so we can't compare it to other versions
//TODO:come up with a more stable way to test for Vasari beta 3
if (context == "Vasari")
{
context = "Vasari 2014";
}
dynamoController = new DynamoController_Revit(DynamoRevitApp.env, DynamoRevitApp.updater, typeof(DynamoRevitViewModel), context);
dynSettings.Bench = new DynamoView {
DataContext = dynamoController.DynamoViewModel
};
dynamoController.UIDispatcher = dynSettings.Bench.Dispatcher;
dynamoView = dynSettings.Bench;
//set window handle and show dynamo
new WindowInteropHelper(dynamoView).Owner = mwHandle;
handledCrash = false;
dynamoView.WindowStartupLocation = WindowStartupLocation.Manual;
Rectangle bounds = Screen.PrimaryScreen.Bounds;
dynamoView.Left = dynamoViewX ?? bounds.X;
dynamoView.Top = dynamoViewY ?? bounds.Y;
dynamoView.Width = dynamoViewWidth ?? 1000.0;
dynamoView.Height = dynamoViewHeight ?? 800.0;
dynamoView.Show();
dynamoView.Dispatcher.UnhandledException += DispatcherOnUnhandledException;
dynamoView.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
});
}
catch (Exception ex)
{
isRunning = false;
MessageBox.Show(ex.ToString());
DynamoLogger.Instance.Log(ex.Message);
DynamoLogger.Instance.Log(ex.StackTrace);
DynamoLogger.Instance.Log("Dynamo log ended " + DateTime.Now.ToString());
return(Result.Failed);
}
return(Result.Succeeded);
}
private static void StartDynamo()
{
try
{
ExecutingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
EmptyTempFolder();
}
DynamoLogger.Instance.StartLogging();
//create a new instance of the ViewModel
controller = new DynamoController(new FSchemeInterop.ExecutionEnvironment(), false, typeof(DynamoViewModel), Context.NONE);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
/// <summary>
/// Enumerate the types in an assembly and add them to DynamoController's
/// dictionaries and the search view model. Internally catches exceptions and sends the error
/// to the console.
/// </summary>
/// <param name="searchViewModel">The searchViewModel to which the nodes will be added</param>
/// <param name="controller">The DynamoController, whose dictionaries will be modified</param>
/// <param name="bench">The bench where logging errors will be sent</param>
private static void LoadNodesFromAssembly(Assembly assembly, SearchViewModel searchViewModel, DynamoController controller)
{
try
{
Type[] loadedTypes = assembly.GetTypes();
foreach (Type t in loadedTypes)
{
try
{
//only load types that are in the right namespace, are not abstract
//and have the elementname attribute
object[] attribs = t.GetCustomAttributes(typeof (NodeNameAttribute), false);
if (IsNodeSubType(t) && attribs.Length > 0)
{
//if we are running in revit (or any context other than NONE) use the DoNotLoadOnPlatforms attribute,
//if available, to discern whether we should load this type
if (!controller.Context.Equals(Context.NONE))
{
object[] platformExclusionAttribs = t.GetCustomAttributes(typeof(DoNotLoadOnPlatformsAttribute), false);
if (platformExclusionAttribs.Length > 0)
{
string[] exclusions = (platformExclusionAttribs[0] as DoNotLoadOnPlatformsAttribute).Values;
if (exclusions.Contains(controller.Context))
//if the attribute's values contain the context stored on the controller
//then skip loading this type.
continue;
}
}
searchViewModel.Add(t);
string typeName = (attribs[0] as NodeNameAttribute).Name;
var data = new TypeLoadData(assembly, t);
if (!controller.BuiltInTypesByNickname.ContainsKey(typeName))
{
controller.BuiltInTypesByNickname.Add(typeName, data);
}
else
{
dynSettings.Controller.DynamoViewModel.Log("Duplicate type encountered: " + typeName);
}
if (!controller.BuiltInTypesByName.ContainsKey(t.FullName))
{
controller.BuiltInTypesByName.Add(t.FullName, data);
}
else
{
dynSettings.Controller.DynamoViewModel.Log("Duplicate type encountered: " + typeName);
}
}
}
catch (Exception e)
{
dynSettings.Controller.DynamoViewModel.Log("Failed to load type from " + assembly.FullName);
dynSettings.Controller.DynamoViewModel.Log("The type was " + t.FullName);
dynSettings.Controller.DynamoViewModel.Log(e);
}
}
}
catch (Exception e)
{
dynSettings.Controller.DynamoViewModel.Log("Could not load types.");
dynSettings.Controller.DynamoViewModel.Log(e);
if (e is ReflectionTypeLoadException)
{
var typeLoadException = e as ReflectionTypeLoadException;
Exception[] loaderExceptions = typeLoadException.LoaderExceptions;
dynSettings.Controller.DynamoViewModel.Log("Dll Load Exception: " + loaderExceptions[0]);
dynSettings.Controller.DynamoViewModel.Log(loaderExceptions[0].ToString());
if (loaderExceptions.Count() > 1)
{
dynSettings.Controller.DynamoViewModel.Log("Dll Load Exception: " + loaderExceptions[1]);
dynSettings.Controller.DynamoViewModel.Log(loaderExceptions[1].ToString());
}
}
}
}
/// <summary>
/// Enumerate local library assemblies and add them to DynamoController's
/// dictionaries and search.
/// </summary>
/// <param name="searchViewModel">The searchViewModel to which the nodes will be added</param>
/// <param name="controller">The DynamoController, whose dictionaries will be modified</param>
internal static void LoadBuiltinTypes(SearchViewModel searchViewModel, DynamoController controller)
{
Assembly dynamoAssembly = Assembly.GetExecutingAssembly();
string location = Path.GetDirectoryName(dynamoAssembly.Location);
#region determine assemblies to load
var allLoadedAssembliesByPath = new Dictionary<string, Assembly>();
var allLoadedAssemblies = new Dictionary<string, Assembly>();
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
allLoadedAssembliesByPath[assembly.Location] = assembly;
allLoadedAssemblies[assembly.FullName] = assembly;
}
string path = Path.Combine(location, "packages");
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
IEnumerable<string> allDynamoAssemblyPaths =
Directory.GetFiles(location, "*.dll")
.Concat(Directory.GetFiles(
path,
"*.dll",
SearchOption.AllDirectories));
var resolver = new ResolveEventHandler(delegate(object sender, ResolveEventArgs args)
{
Assembly result;
allLoadedAssemblies.TryGetValue(args.Name, out result);
return result;
});
AppDomain.CurrentDomain.AssemblyResolve += resolver;
foreach (string assemblyPath in allDynamoAssemblyPaths)
{
if (allLoadedAssembliesByPath.ContainsKey(assemblyPath))
LoadNodesFromAssembly(allLoadedAssembliesByPath[assemblyPath], searchViewModel, controller);
else
{
try
{
Assembly assembly = Assembly.LoadFrom(assemblyPath);
allLoadedAssemblies[assembly.GetName().Name] = assembly;
LoadNodesFromAssembly(assembly, searchViewModel, controller);
}
catch
{
}
}
}
AppDomain.CurrentDomain.AssemblyResolve -= resolver;
#endregion
}
public DynamoRevitViewModel(DynamoController controller, string commandFilePath)
: base(controller, commandFilePath)
{
}
public DynamoViewModel(DynamoController controller)
{
ConnectorType = ConnectorType.BEZIER;
//create the model
_model = new DynamoModel();
dynSettings.Controller.DynamoModel = _model;
//register for property change notifications
//on the model and the controller
_model.PropertyChanged += _model_PropertyChanged;
dynSettings.Controller.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Controller_PropertyChanged);
_model.Workspaces.CollectionChanged += Workspaces_CollectionChanged;
_model.AddHomeWorkspace();
_model.CurrentSpace = _model.HomeSpace;
Controller = controller;
OpenCommand = new DelegateCommand(_model.Open, _model.CanOpen);
ShowOpenDialogAndOpenResultCommand = new DelegateCommand(_model.ShowOpenDialogAndOpenResult, _model.CanShowOpenDialogAndOpenResultCommand);
WriteToLogCmd = new DelegateCommand(_model.WriteToLog, _model.CanWriteToLog);
PostUiActivationCommand = new DelegateCommand(_model.PostUIActivation, _model.CanDoPostUIActivation);
AddNoteCommand = new DelegateCommand(_model.AddNote, _model.CanAddNote);
LayoutAllCommand = new DelegateCommand(_model.LayoutAll, _model.CanLayoutAll);
AddToSelectionCommand = new DelegateCommand(_model.AddToSelection, _model.CanAddToSelection);
ShowNewFunctionDialogCommand = new DelegateCommand(_model.ShowNewFunctionDialogAndMakeFunction, _model.CanShowNewFunctionDialogCommand);
CreateNodeCommand = new DelegateCommand(_model.CreateNode, _model.CanCreateNode);
CreateConnectionCommand = new DelegateCommand(_model.CreateConnection, _model.CanCreateConnection);
ClearCommand = new DelegateCommand(_model.Clear, _model.CanClear);
GoHomeCommand = new DelegateCommand(GoHomeView, CanGoHomeView);
SelectAllCommand = new DelegateCommand(SelectAll, CanSelectAll);
ShowSaveDialogAndSaveResultCommand = new DelegateCommand(ShowSaveDialogAndSaveResult, CanShowSaveDialogAndSaveResult);
SaveCommand = new DelegateCommand(_model.Save, _model.CanSave);
SaveAsCommand = new DelegateCommand(_model.SaveAs, _model.CanSaveAs);
HomeCommand = new DelegateCommand(_model.Home, _model.CanGoHome);
NewHomeWorkspaceCommand = new DelegateCommand(MakeNewHomeWorkspace, CanMakeNewHomeWorkspace);
GoToWorkspaceCommand = new DelegateCommand(GoToWorkspace, CanGoToWorkspace);
DeleteCommand = new DelegateCommand(_model.Delete, _model.CanDelete);
ExitCommand = new DelegateCommand(Exit, CanExit);
ToggleFullscreenWatchShowingCommand = new DelegateCommand(ToggleFullscreenWatchShowing, CanToggleFullscreenWatchShowing);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
AlignSelectedCommand = new DelegateCommand(AlignSelected, CanAlignSelected);;
ShowSaveDialogIfNeededAndSaveResultCommand = new DelegateCommand(ShowSaveDialogIfNeededAndSaveResult, CanShowSaveDialogIfNeededAndSaveResultCommand);
RefactorCustomNodeCommand = new DelegateCommand(_model.RefactorCustomNode, _model.CanRefactorCustomNode);
SaveImageCommand = new DelegateCommand(SaveImage, CanSaveImage);
ShowSaveImageDialogAndSaveResultCommand = new DelegateCommand(ShowSaveImageDialogAndSaveResult, CanShowSaveImageDialogAndSaveResult);
CopyCommand = new DelegateCommand(_model.Copy, _model.CanCopy);
PasteCommand = new DelegateCommand(_model.Paste, _model.CanPaste);
ToggleConsoleShowingCommand = new DelegateCommand(ToggleConsoleShowing, CanToggleConsoleShowing);
CancelRunCommand = new DelegateCommand(Controller.CancelRun, Controller.CanCancelRun);
RunExpressionCommand = new DelegateCommand(Controller.RunExpression, Controller.CanRunExpression);
DisplayFunctionCommand = new DelegateCommand(Controller.DisplayFunction, Controller.CanDisplayFunction);
SetConnectorTypeCommand = new DelegateCommand(SetConnectorType, CanSetConnectorType);
ReportABugCommand = new DelegateCommand(Controller.ReportABug, Controller.CanReportABug);
GoToWikiCommand = new DelegateCommand(GoToWiki, CanGoToWiki);
GoToSourceCodeCommand = new DelegateCommand(GoToSourceCode, CanGoToSourceCode);
ShowPackageManagerSearchCommand = new DelegateCommand(ShowPackageManagerSearch, CanShowPackageManagerSearch);
ShowInstalledPackagesCommand = new DelegateCommand(ShowInstalledPackages, CanShowInstalledPackages);
PublishCurrentWorkspaceCommand = new DelegateCommand(PublishCurrentWorkspace, CanPublishCurrentWorkspace);
PublishSelectedNodesCommand = new DelegateCommand(PublishSelectedNodes, CanPublishSelectedNodes);
ShowHideConnectorsCommand = new DelegateCommand(ShowConnectors, CanShowConnectors);
SelectNeighborsCommand = new DelegateCommand(SelectNeighbors, CanSelectNeighbors);
ClearLogCommand = new DelegateCommand(dynSettings.Controller.ClearLog, dynSettings.Controller.CanClearLog);
PanCommand = new DelegateCommand(Pan, CanPan);
DynamoLogger.Instance.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Instance_PropertyChanged);
DynamoSelection.Instance.Selection.CollectionChanged += SelectionOnCollectionChanged;
}
/// <summary>
/// Get a guid from the name of a node. If it doesn't exist, returns Guid.Empty.
/// </summary>
/// <param name="guid">Open a definition from a path, without instantiating the nodes or dependents</param>
public bool GetNodeInstance(DynamoController controller, string name, out Function result)
{
if (!Contains(name))
{
result = null;
return false;
}
return GetNodeInstance(GetGuidFromName(name), out result);
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences)
{
//create a new instance of the ViewModel
Controller = new DynamoController(typeof(DynamoViewModel), Context.NONE, updateManager, watchHandler, preferences);
DynamoController.IsTestMode = true;
}
public DynamoViewModel(DynamoController controller, string commandFilePath)
{
//create the model
_model = new DynamoModel();
dynSettings.Controller.DynamoModel = _model;
//register for property change notifications
//on the model and the controller
_model.PropertyChanged += _model_PropertyChanged;
dynSettings.Controller.PropertyChanged += Controller_PropertyChanged;
_model.Workspaces.CollectionChanged += Workspaces_CollectionChanged;
_model.AddHomeWorkspace();
_model.CurrentWorkspace = _model.HomeSpace;
Controller = controller;
//Register for a notification when the update manager downloads an update
dynSettings.Controller.UpdateManager.UpdateDownloaded += Instance_UpdateDownloaded;
// Instantiate an AutomationSettings to handle record/playback.
automationSettings = new AutomationSettings(this, commandFilePath);
OpenCommand = new DelegateCommand(_model.Open, _model.CanOpen);
ShowOpenDialogAndOpenResultCommand = new DelegateCommand(_model.ShowOpenDialogAndOpenResult, _model.CanShowOpenDialogAndOpenResultCommand);
WriteToLogCmd = new DelegateCommand(_model.WriteToLog, _model.CanWriteToLog);
PostUiActivationCommand = new DelegateCommand(_model.PostUIActivation, _model.CanDoPostUIActivation);
AddNoteCommand = new DelegateCommand(_model.AddNote, _model.CanAddNote);
AddToSelectionCommand = new DelegateCommand(_model.AddToSelection, _model.CanAddToSelection);
ShowNewFunctionDialogCommand = new DelegateCommand(_model.ShowNewFunctionDialogAndMakeFunction, _model.CanShowNewFunctionDialogCommand);
SaveRecordedCommand = new DelegateCommand(SaveRecordedCommands, CanSaveRecordedCommands);
InsertPausePlaybackCommand = new DelegateCommand(ExecInsertPausePlaybackCommand, CanInsertPausePlaybackCommand);
GoHomeCommand = new DelegateCommand(GoHomeView, CanGoHomeView);
SelectAllCommand = new DelegateCommand(SelectAll, CanSelectAll);
ShowSaveDialogAndSaveResultCommand = new DelegateCommand(ShowSaveDialogAndSaveResult, CanShowSaveDialogAndSaveResult);
SaveCommand = new DelegateCommand(_model.Save, _model.CanSave);
SaveAsCommand = new DelegateCommand(_model.SaveAs, _model.CanSaveAs);
HomeCommand = new DelegateCommand(_model.Home, _model.CanGoHome);
NewHomeWorkspaceCommand = new DelegateCommand(MakeNewHomeWorkspace, CanMakeNewHomeWorkspace);
GoToWorkspaceCommand = new DelegateCommand(GoToWorkspace, CanGoToWorkspace);
DeleteCommand = new DelegateCommand(_model.Delete, _model.CanDelete);
ExitCommand = new DelegateCommand(Exit, CanExit);
ToggleFullscreenWatchShowingCommand = new DelegateCommand(ToggleFullscreenWatchShowing, CanToggleFullscreenWatchShowing);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
AlignSelectedCommand = new DelegateCommand(AlignSelected, CanAlignSelected); ;
ShowSaveDialogIfNeededAndSaveResultCommand = new DelegateCommand(ShowSaveDialogIfNeededAndSaveResult, CanShowSaveDialogIfNeededAndSaveResultCommand);
SaveImageCommand = new DelegateCommand(SaveImage, CanSaveImage);
ShowSaveImageDialogAndSaveResultCommand = new DelegateCommand(ShowSaveImageDialogAndSaveResult, CanShowSaveImageDialogAndSaveResult);
UndoCommand = new DelegateCommand(Undo, CanUndo);
RedoCommand = new DelegateCommand(Redo, CanRedo);
CopyCommand = new DelegateCommand(_model.Copy, _model.CanCopy);
PasteCommand = new DelegateCommand(_model.Paste, _model.CanPaste);
ToggleConsoleShowingCommand = new DelegateCommand(ToggleConsoleShowing, CanToggleConsoleShowing);
CancelRunCommand = new DelegateCommand(Controller.CancelRunCmd, Controller.CanCancelRunCmd);
RunExpressionCommand = new DelegateCommand(Controller.RunExprCmd, Controller.CanRunExprCmd);
DisplayFunctionCommand = new DelegateCommand(Controller.DisplayFunction, Controller.CanDisplayFunction);
SetConnectorTypeCommand = new DelegateCommand(SetConnectorType, CanSetConnectorType);
ReportABugCommand = new DelegateCommand(Controller.ReportABug, Controller.CanReportABug);
GoToWikiCommand = new DelegateCommand(GoToWiki, CanGoToWiki);
GoToSourceCodeCommand = new DelegateCommand(GoToSourceCode, CanGoToSourceCode);
ShowPackageManagerSearchCommand = new DelegateCommand(ShowPackageManagerSearch, CanShowPackageManagerSearch);
ShowInstalledPackagesCommand = new DelegateCommand(ShowInstalledPackages, CanShowInstalledPackages);
PublishCurrentWorkspaceCommand = new DelegateCommand(PublishCurrentWorkspace, CanPublishCurrentWorkspace);
PublishSelectedNodesCommand = new DelegateCommand(PublishSelectedNodes, CanPublishSelectedNodes);
ShowHideConnectorsCommand = new DelegateCommand(ShowConnectors, CanShowConnectors);
SelectNeighborsCommand = new DelegateCommand(SelectNeighbors, CanSelectNeighbors);
ClearLogCommand = new DelegateCommand(dynSettings.Controller.ClearLog, dynSettings.Controller.CanClearLog);
PanCommand = new DelegateCommand(Pan, CanPan);
ZoomInCommand = new DelegateCommand(ZoomIn, CanZoomIn);
ZoomOutCommand = new DelegateCommand(ZoomOut, CanZoomOut);
FitViewCommand = new DelegateCommand(FitView, CanFitView);
TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan);
EscapeCommand = new DelegateCommand(Escape, CanEscape);
SelectVisualizationInViewCommand = new DelegateCommand(SelectVisualizationInView, CanSelectVisualizationInView);
GetBranchVisualizationCommand = new DelegateCommand(GetBranchVisualization, CanGetBranchVisualization);
TogglePreviewBubbleVisibilityCommand = new DelegateCommand(TogglePreviewBubbleVisibility, CanTogglePreviewBubbleVisibility);
ExportToSTLCommand = new DelegateCommand(ExportToSTL, CanExportToSTL);
ImportLibraryCommand = new DelegateCommand(ImportLibrary, CanImportLibrary);
SetLengthUnitCommand = new DelegateCommand(SetLengthUnit, CanSetLengthUnit);
SetAreaUnitCommand = new DelegateCommand(SetAreaUnit, CanSetAreaUnit);
SetVolumeUnitCommand = new DelegateCommand(SetVolumeUnit, CanSetVolumeUnit);
ShowAboutWindowCommand = new DelegateCommand(ShowAboutWindow, CanShowAboutWindow);
CheckForUpdateCommand = new DelegateCommand(CheckForUpdate, CanCheckForUpdate);
SetNumberFormatCommand = new DelegateCommand(SetNumberFormat, CanSetNumberFormat);
DynamoLogger.Instance.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Instance_PropertyChanged);
DynamoSelection.Instance.Selection.CollectionChanged += SelectionOnCollectionChanged;
dynSettings.Controller.VisualizationManager.PropertyChanged += VisualizationManager_PropertyChanged;
this.Model.PropertyChanged += (e, args) =>
{
if (args.PropertyName == "CurrentWorkspace" && dynSettings.Controller.DynamoModel.CurrentWorkspace != null)
{
var visibleWorkspace =
(dynSettings.Controller.DynamoModel.CurrentWorkspace is CustomNodeWorkspaceModel);
dynSettings.Controller.SearchViewModel.SearchElements
.Where(x => x.Name == "Input" || x.Name == "Output")
.OfType<NodeSearchElement>()
.ToList()
.ForEach(x => x.SetSearchable(visibleWorkspace));
dynSettings.Controller.SearchViewModel.SearchAndUpdateResultsSync();
}
};
UsageReportingManager.Instance.PropertyChanged += CollectInfoManager_PropertyChanged;
WatchIsResizable = false;
}
public MutatorDriver(DynamoController dynamoController)
{
this.dynamoController = dynamoController;
}
