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
{
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 Loaded(ViewLoadedParams p)
{
viewLoadedParams = p;
dynamoWindow = p.DynamoWindow;
var viewModel = dynamoWindow.DataContext as DynamoViewModel;
logger = viewModel.Model.Logger;
Notifications = new ObservableCollection <Logging.NotificationMessage>();
notificationHandler = (notificationMessage) =>
{
Notifications.Add(notificationMessage);
AddNotifications();
};
p.NotificationRecieved += notificationHandler;
//add a new menuItem to the Dynamo mainMenu.
notificationsMenuItem = new NotificationsMenuItem(this);
//null out the content of the notificationsMenu to get rid of
//the parent of the menuItem we created
(notificationsMenuItem.MenuItem.Parent as ContentControl).Content = null;
//place the menu into the DynamoMenu
p.dynamoMenu.Items.Add(notificationsMenuItem.MenuItem);
}
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);
}
}
public AboutWindow(DynamoLogger logger, DynamoViewModel model)
{
InitializeComponent();
this.logger = logger;
this.InstallNewUpdate = false;
this.PreviewKeyDown += new KeyEventHandler(HandleEsc);
this.DataContext = model;
}
internal static void RequestPythonResetHandler(string pythonEngine)
{
//check if python engine request is for this engine, and engine is currently started
if (PythonEngine.IsInitialized && pythonEngine == "CPython3")
{
DynamoLogger?.Log("attempting reload of cpython3 modules", LogLevel.Console);
using (Py.GIL())
{
//the following is inspired by:
//https://github.com/ipython/ipython/blob/master/IPython/extensions/autoreload.py
var global = PyScopeManager.Global.Get(CPythonEvaluator.globalScopeName);
global?.Exec(@"import sys
import importlib
import importlib.util
import os
## Reloading sys, __main__, builtins and other key modules is not recommended.
## don't reload modules without file attributes
def should_reload(module):
if not hasattr(module, '__file__') or module.__file__ is None:
return None
## don't reload modules that are currently running ie __main__, __mp_main__ is renamed by multiprocessing module.
if getattr(module, '__name__', None) in [None, '__mp_main__', '__main__']:
# we cannot reload(__main__) or reload(__mp_main__)
return None
filename = module.__file__
path, ext = os.path.splitext(filename)
## only reload .py files.
if ext.lower() == '.py':
py_filename = filename
else:
try:
py_filename = importlib.util.source_from_cache(filename)
except ValueError:
return None
return py_filename
## copy sys.modules so it's not modified during reload.
for modname,mod in sys.modules.copy().items():
print('considering', modname)
file = should_reload(mod)
if file is None:
continue
print('reloading', modname)
try:
importlib.reload(mod)
except Exception as inst:
print('failed to reload', modname, inst)
");
}
Analytics.TrackEvent(
Dynamo.Logging.Actions.Start,
Dynamo.Logging.Categories.PythonOperations,
"CPythonReset");
}
}
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 UpdateButtonCollapsedIfUpToDate()
{
var logger = new DynamoLogger();
dynSettings.DynamoLogger = logger;
var um_mock = new Mock<IUpdateManager>();
um_mock.Setup(um => um.AvailableVersion).Returns(BinaryVersion.FromString("1.1.1.1"));
um_mock.Setup(um => um.ProductVersion).Returns(BinaryVersion.FromString("9.9.9.9"));
Init(um_mock.Object);
var stb = (ShortcutToolbar)Ui.shortcutBarGrid.Children[0];
var sbgrid = (Grid)stb.FindName("ShortcutToolbarGrid");
var updateControl = (GraphUpdateNotificationControl)sbgrid.FindName("UpdateControl");
Assert.AreEqual(Visibility.Collapsed, updateControl.Visibility);
}
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();
}
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();
}
public void test_dynamologger_logger()
{
//Arrange
//This has been done in the base class but we need to do it again because the pathManager is private
var config = CreateStartConfiguration(dynamoSettings);
pathManager = new PathManager(new PathManagerParams
{
CorePath = config.DynamoCorePath,
HostPath = config.DynamoHostPath,
PathResolver = config.PathResolver
});
// Ensure we have all directories in place.
var exceptions = new List <Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
//By setting the VerboseLogging we will enable a piece of code inside the method::
//private void Log(string message, LogLevel level, bool reportModification)
var debugSettings = new DebugSettings
{
VerboseLogging = true
};
var logger = new DynamoLogger(debugSettings, pathManager.LogDirectory);
//Act
logger.LogWarning("Testing Logging Warning", WarningLevel.Error);
Assert.AreEqual(logger.WarningLevel, WarningLevel.Error);
Assert.AreEqual(logger.Warning, "Testing Logging Warning");
logger.ResetWarning();
logger.LogInfo("Testing Logging Warning", "info test");
logger.LogError("Testing Logging Error", "Error Details");
//Assert
//Check if the logged info was inserted inside the logged text (the log file cannot be opened due that is being used by the base class)
Assert.IsTrue(logger.LogText.Contains("Testing Logging Warning"));
logger.Dispose();
logger.Dispose();//Calling a second time this function will enter in a validation not covered
}
// Returns the dynamo logger object in non-test mode.
internal DynamoLogger GetDynamoLoggerWithTestModeFalse()
{
pathManager = new PathManager(new PathManagerParams {
});
// Ensure we have all directories in place.
var exceptions = new List <Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
//By setting the VerboseLogging we will enable a piece of code inside the method::
//private void Log(string message, LogLevel level, bool reportModification)
var debugSettings = new DebugSettings
{
VerboseLogging = true
};
var logger = new DynamoLogger(debugSettings, pathManager.LogDirectory, false);
return(logger);
}
public void test_dynamologger_logger()
{
// Get the dynamo logger in non-test mode, as we write the logs
// to dynamo console and to a file only in non-test mode.
logger = GetDynamoLoggerWithTestModeFalse();
//Act
logger.LogWarning("Testing Logging Warning", WarningLevel.Error);
Assert.AreEqual(logger.WarningLevel, WarningLevel.Error);
Assert.AreEqual(logger.Warning, "Testing Logging Warning");
logger.ResetWarning();
logger.LogInfo("Testing Logging Warning", "info test");
logger.LogError("Testing Logging Error", "Error Details");
//Assert
//Check if the logged info is stored in the LogText property (the log file cannot be opened due that is being used by the base class)
Assert.IsTrue(logger.LogText.Contains("Testing Logging Warning"));
logger.Dispose();
logger.Dispose();//Calling a second time this function will enter in a validation not covered
}
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);
}
}
public static DynamoController_Revit CreateDynamoRevitControllerAndViewModel(
RevitServicesUpdater updater, DynamoLogger logger, string context)
{
BaseUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
BaseUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
BaseUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var updateManager = new UpdateManager.UpdateManager(logger);
string corePath =
Path.GetFullPath(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\..\");
var dynamoController = new DynamoController_Revit(
updater,
context,
updateManager,
corePath);
// Generate a view model to be the data context for the view
dynamoController.DynamoViewModel = new DynamoRevitViewModel(dynamoController, null);
dynamoController.DynamoViewModel.RequestAuthentication +=
dynamoController.RegisterSingleSignOn;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.CanFindNodesFromElements = true;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.FindNodesFromElements =
dynamoController.FindNodesFromSelection;
// Register the view model to handle sign-on requests
dynSettings.Controller.DynamoViewModel.RequestAuthentication +=
dynamoController.RegisterSingleSignOn;
dynamoController.VisualizationManager = new VisualizationManagerRevit();
return dynamoController;
}
/// <summary>
/// Attempt to create a HelixWatch3DViewModel. If one cannot be created,
/// fall back to creating a DefaultWatch3DViewModel and log the exception.
/// </summary>
/// <param name="model">The NodeModel to associate with the returned view model.</param>
/// <param name="parameters">A Watch3DViewModelStartupParams object.</param>
/// <param name="logger">A logger to be used to log the exception.</param>
/// <returns></returns>
public static DefaultWatch3DViewModel TryCreateHelixWatch3DViewModel(NodeModel model, Watch3DViewModelStartupParams parameters, DynamoLogger logger)
{
try
{
var vm = new HelixWatch3DViewModel(model, parameters);
return(vm);
}
catch (Exception ex)
{
logger.Log(Resources.BackgroundPreviewCreationFailureMessage, LogLevel.Console);
logger.Log(ex.Message, LogLevel.File);
var vm = new DefaultWatch3DViewModel(model, parameters)
{
Active = false,
CanBeActivated = false
};
return(vm);
}
}
//TODO: Remove this after testing.
//For testing purpose.
public ResourceHandlerFactory(DynamoLogger log)
{
this.logger = log;
}
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 += 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
{
#region default level
var fecLevel = new FilteredElementCollector(revit.Application.ActiveUIDocument.Document);
fecLevel.OfClass(typeof(Level));
var defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
if (DocumentManager.Instance.CurrentUIApplication == null)
DocumentManager.Instance.CurrentUIApplication = revit.Application;
DocumentManager.OnLogError += dynSettings.Controller.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";
BaseUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
BaseUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
BaseUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
dynamoController = new DynamoController_Revit(Updater, context, updateManager,logger);
// Generate a view model to be the data context for the view
dynamoController.DynamoViewModel = new DynamoRevitViewModel(dynamoController, null);
dynamoController.DynamoViewModel.RequestAuthentication += ((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.CanFindNodesFromElements = true;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.FindNodesFromElements = ((DynamoController_Revit)dynamoController).FindNodesFromSelection;
// Register the view model to handle sign-on requests
dynSettings.Controller.DynamoViewModel.RequestAuthentication += ((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.VisualizationManager = new VisualizationManagerRevit();
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.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
revit.Application.ViewActivating += Application_ViewActivating;
});
}
catch (Exception ex)
{
isRunning = false;
MessageBox.Show(ex.ToString());
dynSettings.Controller.DynamoLogger.LogError(ex.Message);
dynSettings.Controller.DynamoLogger.LogError(ex.StackTrace);
dynSettings.Controller.DynamoLogger.LogError("Dynamo log ended " + DateTime.Now);
return Result.Failed;
}
return Result.Succeeded;
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
AppDomain.CurrentDomain.AssemblyResolve += 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
{
#region default level
var fecLevel = new FilteredElementCollector(revit.Application.ActiveUIDocument.Document);
fecLevel.OfClass(typeof(Level));
var defaultLevel = fecLevel.ToElements()[0] as Level;
#endregion
if (DocumentManager.Instance.CurrentUIApplication == null)
{
DocumentManager.Instance.CurrentUIApplication = revit.Application;
}
DocumentManager.OnLogError += dynSettings.Controller.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";
}
BaseUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
BaseUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
BaseUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var logger = new DynamoLogger();
var updateManager = new UpdateManager.UpdateManager(logger);
dynamoController = new DynamoController_Revit(Updater, context, updateManager, logger);
// Generate a view model to be the data context for the view
dynamoController.DynamoViewModel = new DynamoRevitViewModel(dynamoController, null);
dynamoController.DynamoViewModel.RequestAuthentication += ((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.CanFindNodesFromElements = true;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.FindNodesFromElements = ((DynamoController_Revit)dynamoController).FindNodesFromSelection;
// Register the view model to handle sign-on requests
dynSettings.Controller.DynamoViewModel.RequestAuthentication += ((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.VisualizationManager = new VisualizationManagerRevit();
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.Closing += dynamoView_Closing;
dynamoView.Closed += dynamoView_Closed;
revit.Application.ViewActivating += Application_ViewActivating;
});
}
catch (Exception ex)
{
isRunning = false;
MessageBox.Show(ex.ToString());
dynSettings.Controller.DynamoLogger.LogError(ex.Message);
dynSettings.Controller.DynamoLogger.LogError(ex.StackTrace);
dynSettings.Controller.DynamoLogger.LogError("Dynamo log ended " + DateTime.Now);
return(Result.Failed);
}
return(Result.Succeeded);
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
if (revit.JournalData != null &&
revit.JournalData.ContainsKey("debug"))
{
if (bool.Parse(revit.JournalData["debug"]))
{
Debugger.Launch();
}
}
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
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.
var assLoc = Assembly.GetExecutingAssembly().Location;
var interactivityPath = Path.Combine(Path.GetDirectoryName(assLoc), "System.Windows.Interactivity.dll");
var interactivityAss = Assembly.LoadFrom(interactivityPath);
DynamoRevitApp.dynamoButton.Enabled = false;
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();
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;
});
}
catch (Exception ex)
{
//isRunning = false;
MessageBox.Show(ex.ToString());
dynSettings.DynamoLogger.LogError(ex.Message);
dynSettings.DynamoLogger.LogError(ex.StackTrace);
dynSettings.DynamoLogger.LogError("Dynamo log ended " + DateTime.Now);
return(Result.Failed);
}
return(Result.Succeeded);
}
public static DynamoController_Revit CreateDynamoRevitControllerAndViewModel(RevitServicesUpdater updater, DynamoLogger logger, string context)
{
BaseUnit.HostApplicationInternalAreaUnit = DynamoAreaUnit.SquareFoot;
BaseUnit.HostApplicationInternalLengthUnit = DynamoLengthUnit.DecimalFoot;
BaseUnit.HostApplicationInternalVolumeUnit = DynamoVolumeUnit.CubicFoot;
var updateManager = new UpdateManager.UpdateManager(logger);
var dynamoController = new DynamoController_Revit(updater, context, updateManager);
// Generate a view model to be the data context for the view
dynamoController.DynamoViewModel = new DynamoRevitViewModel(dynamoController, null);
dynamoController.DynamoViewModel.RequestAuthentication +=
((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.CanFindNodesFromElements = true;
dynamoController.DynamoViewModel.CurrentSpaceViewModel.FindNodesFromElements =
((DynamoController_Revit)dynamoController).FindNodesFromSelection;
// Register the view model to handle sign-on requests
dynSettings.Controller.DynamoViewModel.RequestAuthentication +=
((DynamoController_Revit)dynamoController).RegisterSingleSignOn;
dynamoController.VisualizationManager = new VisualizationManagerRevit();
return(dynamoController);
}
protected DynamoModel(IStartConfiguration config)
{
ClipBoard = new ObservableCollection<ModelBase>();
pathManager = new PathManager(new PathManagerParams
{
CorePath = config.DynamoCorePath,
PathResolver = config.PathResolver
});
// Ensure we have all directories in place.
var exceptions = new List<Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
Context = config.Context;
IsTestMode = config.StartInTestMode;
DebugSettings = new DebugSettings();
Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);
foreach (var exception in exceptions)
{
Logger.Log(exception); // Log all exceptions.
}
MigrationManager = new MigrationManager(DisplayFutureFileMessage, DisplayObsoleteFileMessage);
MigrationManager.MessageLogged += LogMessage;
MigrationManager.MigrationTargets.Add(typeof(WorkspaceMigrations));
var thread = config.SchedulerThread ?? new DynamoSchedulerThread();
Scheduler = new DynamoScheduler(thread, IsTestMode);
Scheduler.TaskStateChanged += OnAsyncTaskStateChanged;
geometryFactoryPath = config.GeometryFactoryPath;
IPreferences preferences = CreateOrLoadPreferences(config.Preferences);
var settings = preferences as PreferenceSettings;
if (settings != null)
{
PreferenceSettings = settings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializePreferences(preferences);
InitializeInstrumentationLogger();
if (!isTestMode && this.PreferenceSettings.IsFirstRun)
{
DynamoMigratorBase migrator = null;
try
{
migrator = DynamoMigratorBase.MigrateBetweenDynamoVersions(pathManager, config.PathResolver);
}
catch (Exception e)
{
Logger.Log(e.Message);
}
if (migrator != null)
{
var isFirstRun = this.PreferenceSettings.IsFirstRun;
this.PreferenceSettings = migrator.PreferenceSettings;
// Preserve the preference settings for IsFirstRun as this needs to be set
// only by UsageReportingManager
this.PreferenceSettings.IsFirstRun = isFirstRun;
}
}
// At this point, pathManager.PackageDirectories only has 1 element which is the directory
// in AppData. If list of PackageFolders is empty, add the folder in AppData to the list since there
// is no additional location specified. Otherwise, update pathManager.PackageDirectories to include
// PackageFolders
if (PreferenceSettings.CustomPackageFolders.Count == 0)
PreferenceSettings.CustomPackageFolders = new List<string> {pathManager.UserDataDirectory};
else
pathManager.LoadCustomPackageFolders(PreferenceSettings.CustomPackageFolders);
SearchModel = new NodeSearchModel();
SearchModel.ItemProduced +=
node => ExecuteCommand(new CreateNodeCommand(node, 0, 0, true, true));
NodeFactory = new NodeFactory();
NodeFactory.MessageLogged += LogMessage;
CustomNodeManager = new CustomNodeManager(NodeFactory, MigrationManager);
InitializeCustomNodeManager();
extensionManager = new ExtensionManager();
extensionManager.MessageLogged += LogMessage;
var extensions = config.Extensions ?? ExtensionManager.ExtensionLoader.LoadDirectory(pathManager.ExtensionsDirectory);
Loader = new NodeModelAssemblyLoader();
Loader.MessageLogged += LogMessage;
DisposeLogic.IsShuttingDown = false;
// Create a core which is used for parsing code and loading libraries
var libraryCore =
new ProtoCore.Core(new Options { RootCustomPropertyFilterPathName = string.Empty });
libraryCore.Compilers.Add(Language.kAssociative, new Compiler(libraryCore));
libraryCore.Compilers.Add(Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
LibraryServices = new LibraryServices(libraryCore, pathManager);
LibraryServices.MessageLogged += LogMessage;
LibraryServices.LibraryLoaded += LibraryLoaded;
ResetEngineInternal();
AddHomeWorkspace();
AuthenticationManager = new AuthenticationManager(config.AuthProvider);
UpdateManager = config.UpdateManager ?? new DefaultUpdateManager(null);
UpdateManager.Log += UpdateManager_Log;
if (!IsTestMode)
{
DefaultUpdateManager.CheckForProductUpdate(UpdateManager);
}
Logger.Log(string.Format("Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
InitializeNodeLibrary(preferences);
if (extensions.Any())
{
var startupParams = new StartupParams(config.AuthProvider,
pathManager, new ExtensionLibraryLoader(this),
CustomNodeManager, GetType().Assembly.GetName().Version);
foreach (var ext in extensions)
{
var logSource = ext as ILogSource;
if (logSource != null)
logSource.MessageLogged += LogMessage;
ext.Startup(startupParams);
ext.Load(preferences, pathManager);
ExtensionManager.Add(ext);
}
}
LogWarningMessageEvents.LogWarningMessage += LogWarningMessage;
StartBackupFilesTimer();
TraceReconciliationProcessor = this;
foreach (var ext in ExtensionManager.Extensions)
{
try
{
ext.Ready(new ReadyParams(this));
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
}
}
private UpdateManager(DynamoLogger logger)
{
this.logger = logger;
}
public static UpdateManager CreateInstance(DynamoLogger logger)
{
if (self != null) return self;
if (null == logger)
throw new ArgumentNullException("logger", "Unspecified logger (61578808A807)");
self = new UpdateManager(logger);
return self;
}
protected DynamoModel(StartConfiguration configuration)
{
string context = configuration.Context;
IPreferences preferences = configuration.Preferences;
string corePath = configuration.DynamoCorePath;
DynamoRunner runner = configuration.Runner;
bool isTestMode = configuration.StartInTestMode;
DynamoPathManager.Instance.InitializeCore(corePath);
UsageReportingManager.Instance.InitializeCore(this);
Runner = runner;
Context = context;
IsTestMode = isTestMode;
Logger = new DynamoLogger(this, DynamoPathManager.Instance.Logs);
DebugSettings = new DebugSettings();
#if ENABLE_DYNAMO_SCHEDULER
var thread = configuration.SchedulerThread ?? new DynamoSchedulerThread();
scheduler = new DynamoScheduler(thread);
#endif
if (preferences is PreferenceSettings)
{
this.PreferenceSettings = preferences as PreferenceSettings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializePreferences(preferences);
InitializeInstrumentationLogger();
UpdateManager.UpdateManager.Instance.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation)));
SearchModel = new SearchModel(this);
InitializeCurrentWorkspace();
this.CustomNodeManager = new CustomNodeManager(this, DynamoPathManager.Instance.UserDefinitions);
this.Loader = new DynamoLoader(this);
this.Loader.PackageLoader.DoCachedPackageUninstalls();
this.Loader.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
this.EngineController = new EngineController(this, DynamoPathManager.Instance.GeometryFactory);
this.CustomNodeManager.RecompileAllNodes(EngineController);
// Reset virtual machine to avoid a race condition by causing a
// thread join inside the vm exec. Since DynamoModel is being called
// on the main/idle thread, it is safe to call ResetEngineInternal
// directly (we cannot call virtual method ResetEngine here).
//
ResetEngineInternal();
Nodes.ForEach(n => n.RequiresRecalc = true);
Logger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
this.Loader.ClearCachedAssemblies();
this.Loader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
PackageManagerClient = new PackageManagerClient(this);
}
public UpdateManager()
{
logger = DynamoLogger.Instance;
}