private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
var assemblyLocation = Assembly.GetExecutingAssembly().Location;
var assemblyDirectory = Path.GetDirectoryName(assemblyLocation);
var parentDirectory = Directory.GetParent(assemblyDirectory);
var corePath = parentDirectory.FullName;
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
Debug.Assert(umConfig.DynamoLookUp != null);
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
GeometryFactoryPath = GetGeometryFactoryPath(corePath),
PathResolver = new RevitPathResolver(),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = new DynUpdateManager(umConfig),
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
private static void InitializeDocumentManager(DynamoRevitCommandData commandData)
{
if (DocumentManager.Instance.CurrentUIApplication == null)
{
DocumentManager.Instance.CurrentUIApplication = commandData.Application;
}
}
private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
var corePath = DynamoRevitApp.DynamoCorePath;
var dynamoRevitExePath = Assembly.GetExecutingAssembly().Location;
var dynamoRevitRoot = Path.GetDirectoryName(dynamoRevitExePath);// ...\Revit_xxxx\ folder
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
Debug.Assert(umConfig.DynamoLookUp != null);
var userDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Dynamo", "Dynamo Revit");
var commonDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
"Dynamo", "Dynamo Revit");
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
DynamoCorePath = corePath,
DynamoHostPath = dynamoRevitRoot,
GeometryFactoryPath = GetGeometryFactoryPath(corePath),
PathResolver = new RevitPathResolver(userDataFolder, commonDataFolder),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = new DynUpdateManager(umConfig),
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
public Result ExecuteCommand(DynamoRevitCommandData commandData)
{
var startupTimer = Stopwatch.StartNew();
HandleDebug(commandData);
InitializeCore(commandData);
try
{
extCommandData = commandData;
shouldShowUi = CheckJournalForUiDisplay(extCommandData);
isAutomationMode = CheckJournalForAutomationMode(extCommandData);
UpdateSystemPathForProcess();
// create core data models
revitDynamoModel = InitializeCoreModel(extCommandData);
dynamoViewModel = InitializeCoreViewModel(revitDynamoModel);
revitDynamoModel.Logger.Log("SYSTEM", string.Format("Environment Path:{0}", Environment.GetEnvironmentVariable("PATH")));
// handle initialization steps after RevitDynamoModel is created.
revitDynamoModel.HandlePostInitialization();
// show the window
if (shouldShowUi)
{
InitializeCoreView().Show();
}
TryOpenAndExecuteWorkspace(extCommandData);
// Disable the Dynamo button to prevent a re-run
DynamoRevitApp.DynamoButtonEnabled = false;
Analytics.TrackStartupTime("DynamoRevit", startupTimer.Elapsed);
}
catch (Exception ex)
{
// notify instrumentation
Analytics.TrackException(ex, true);
MessageBox.Show(ex.ToString());
DynamoRevitApp.DynamoButtonEnabled = true;
//If for some reason Dynamo has crashed while startup make sure the Dynamo Model is properly shutdown.
if (revitDynamoModel != null)
{
revitDynamoModel.ShutDown(false);
revitDynamoModel = null;
}
return(Result.Failed);
}
return(Result.Succeeded);
}
static DynamoRevit()
{
idleActions = new List <Action>();
extCommandData = null;
dynamoViewModel = null;
revitDynamoModel = null;
handledCrash = false;
ModelState = RevitDynamoModelState.NotStarted;
preLoadExceptions = new List <Exception>();
}
private static void HandleDebug(DynamoRevitCommandData commandData)
{
if (commandData.JournalData != null && commandData.JournalData.ContainsKey("debug"))
{
if (Boolean.Parse(commandData.JournalData["debug"]))
{
Debugger.Launch();
}
}
}
private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
// Temporary fix to pre-load DLLs that were also referenced in Revit folder.
// To do: Need to align with Revit when provided a chance.
PreloadDynamoCoreDlls();
var corePath = DynamoRevitApp.DynamoCorePath;
var dynamoRevitExePath = Assembly.GetExecutingAssembly().Location;
var dynamoRevitRoot = Path.GetDirectoryName(dynamoRevitExePath);// ...\Revit_xxxx\ folder
// get Dynamo Revit Version
var dynRevitVersion = Assembly.GetExecutingAssembly().GetName().Version;
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
var revitUpdateManager = new DynUpdateManager(umConfig);
revitUpdateManager.HostVersion = dynRevitVersion; // update RevitUpdateManager with the current DynamoRevit Version
revitUpdateManager.HostName = "Dynamo Revit";
if (revitUpdateManager.Configuration is IDisableUpdateConfig)
{
(revitUpdateManager.Configuration as IDisableUpdateConfig).DisableUpdates = true;
}
Debug.Assert(umConfig.DynamoLookUp != null);
var userDataFolder = Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.ApplicationData),
"Dynamo", "Dynamo Revit");
var commonDataFolder = Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.CommonApplicationData),
"Autodesk", "RVT " + commandData.Application.Application.VersionNumber, "Dynamo");
bool isAutomationMode = CheckJournalForKey(extCommandData, JournalKeys.AutomationModeKey);
// when Dynamo runs on top of Revit we must load the same version of ASM as revit
// so tell Dynamo core we've loaded that version.
var loadedLibGVersion = PreloadAsmFromRevit();
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
DynamoCorePath = corePath,
DynamoHostPath = dynamoRevitRoot,
GeometryFactoryPath = GetGeometryFactoryPath(corePath, loadedLibGVersion),
PathResolver = new RevitPathResolver(userDataFolder, commonDataFolder),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = revitUpdateManager,
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
/// <summary>
/// Executes Dynamo command to show the Dynamo UI
/// </summary>
/// <param name="journalData">Journal data passed for the command</param>
/// <param name="application">Active session of Revit UI application</param>
/// <returns></returns>
public Result ExecuteDynamoCommand(IDictionary <string, string> journalData, UIApplication application)
{
var data = new DynamoRevitCommandData()
{
JournalData = journalData,
Application = application
};
var cmd = new DynamoRevit();
return(cmd.ExecuteCommand(data));
}
private static string GetRevitContext(DynamoRevitCommandData commandData)
{
var r = new Regex(@"\b(Autodesk |Structure |MEP |Architecture )\b");
string context = r.Replace(commandData.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
if (context == "Vasari")
{
context = "Vasari 2014";
}
return(context);
}
public Result ExecuteCommand(DynamoRevitCommandData commandData)
{
HandleDebug(commandData);
InitializeCore(commandData);
try
{
extCommandData = commandData;
shouldShowUi = CheckJournalForUiDisplay(extCommandData);
isAutomationMode = CheckJournalForAutomationMode(extCommandData);
UpdateSystemPathForProcess();
// create core data models
revitDynamoModel = InitializeCoreModel(extCommandData);
dynamoViewModel = InitializeCoreViewModel(revitDynamoModel);
revitDynamoModel.Logger.Log("SYSTEM", string.Format("Environment Path:{0}", Environment.GetEnvironmentVariable("PATH")));
// handle initialization steps after RevitDynamoModel is created.
revitDynamoModel.HandlePostInitialization();
// show the window
if (shouldShowUi)
{
InitializeCoreView().Show();
}
TryOpenAndExecuteWorkspace(extCommandData);
// Disable the Dynamo button to prevent a re-run
DynamoRevitApp.DynamoButtonEnabled = false;
}
catch (Exception ex)
{
// notify instrumentation
InstrumentationLogger.LogException(ex);
StabilityTracking.GetInstance().NotifyCrash();
MessageBox.Show(ex.ToString());
DynamoRevitApp.DynamoButtonEnabled = true;
return(Result.Failed);
}
return(Result.Succeeded);
}
private static bool CheckJournalForKey(DynamoRevitCommandData commandData, string key, bool defaultReturn = false)
{
var result = defaultReturn;
if (commandData.JournalData == null)
{
return(result);
}
if (commandData.JournalData.ContainsKey(key))
{
bool.TryParse(commandData.JournalData[key], out result);
}
return(result);
}
private static bool CheckJournalForUiDisplay(DynamoRevitCommandData commandData)
{
var result = true;
if (commandData.JournalData == null)
{
return(result);
}
if (commandData.JournalData.ContainsKey(JournalShowUiKey))
{
bool.TryParse(commandData.JournalData[JournalShowUiKey], out result);
}
return(result);
}
private static bool CheckJournalForAutomationMode(DynamoRevitCommandData commandData)
{
var result = false;
if (commandData.JournalData == null)
{
return(result);
}
if (commandData.JournalData.ContainsKey(JounralAutomationModeKey))
{
result = bool.TryParse(commandData.JournalData[JounralAutomationModeKey], out result);
}
return(result);
}
private static void TryOpenAndExecuteWorkspace(DynamoRevitCommandData commandData)
{
if (commandData.JournalData == null)
{
return;
}
if (commandData.JournalData.ContainsKey(JournalDynPathKey))
{
revitDynamoModel.OpenFileFromPath(commandData.JournalData[JournalDynPathKey]);
var hs = revitDynamoModel.CurrentWorkspace as HomeWorkspaceModel;
if (hs != null && hs.RunSettings.RunType == RunType.Manual)
{
hs.Run();
}
}
}
private static void InitializeCore(DynamoRevitCommandData commandData)
{
if (initializedCore)
{
return;
}
// Change the locale that LibG depends on.
StringBuilder sb = new StringBuilder("LANGUAGE=");
var revitLocale = System.Globalization.CultureInfo.CurrentUICulture.ToString();
sb.Append(revitLocale.Replace("-", "_"));
_putenv(sb.ToString());
InitializeAssemblies();
InitializeDocumentManager(commandData);
initializedCore = true;
}
private static void TryOpenAndExecuteWorkspaceInCommandData(DynamoRevitCommandData commandData)
{
if (commandData.JournalData == null)
{
return;
}
if (commandData.JournalData.ContainsKey(JournalKeys.DynPathKey))
{
bool isAutomationMode = CheckJournalForKey(commandData, JournalKeys.AutomationModeKey);
bool forceManualRun = CheckJournalForKey(commandData, JournalKeys.ForceManualRunKey);
if (ModelState == RevitDynamoModelState.StartedUIless)
{
revitDynamoModel.OpenFileFromPath(commandData.JournalData[JournalKeys.DynPathKey], forceManualRun);
}
else
{
dynamoViewModel.OpenIfSavedCommand.Execute(new Dynamo.Models.DynamoModel.OpenFileCommand(commandData.JournalData[JournalKeys.DynPathKey], forceManualRun));
dynamoViewModel.ShowStartPage = false;
}
//If we are in automation mode the model will run anyway (on the main thread
//without the idle loop) regardless of the DynPathExecuteKey.
if (!isAutomationMode && commandData.JournalData.ContainsKey(JournalKeys.DynPathExecuteKey))
{
bool executePath = false;
bool.TryParse(commandData.JournalData[JournalKeys.DynPathExecuteKey], out executePath);
if (executePath)
{
HomeWorkspaceModel modelToRun = revitDynamoModel.CurrentWorkspace as HomeWorkspaceModel;
if (modelToRun != null)
{
modelToRun.Run();
return;
}
}
}
}
}
private static void TryOpenAndExecuteWorkspaceInCommandData(DynamoRevitCommandData commandData)
{
if (commandData.JournalData == null)
{
return;
}
if (commandData.JournalData.ContainsKey(JournalKeys.DynPathKey))
{
bool isAutomationMode = CheckJournalForKey(commandData, JournalKeys.AutomationModeKey);
bool forceManualRun = CheckJournalForKey(commandData, JournalKeys.ForceManualRunKey);
bool useExistingWorkspace = false;
if (CheckJournalForKey(commandData, JournalKeys.DynPathCheckExisting))
{
WorkspaceModel currentWorkspace = revitDynamoModel.CurrentWorkspace;
if (currentWorkspace.FileName.Equals(commandData.JournalData[JournalKeys.DynPathKey],
StringComparison.OrdinalIgnoreCase))
{
useExistingWorkspace = true;
}
}
if (!useExistingWorkspace) //if use existing is false, open the specified workspace
{
if (ModelState == RevitDynamoModelState.StartedUIless)
{
revitDynamoModel.OpenFileFromPath(commandData.JournalData[JournalKeys.DynPathKey], forceManualRun);
}
else
{
dynamoViewModel.OpenIfSavedCommand.Execute(new Dynamo.Models.DynamoModel.OpenFileCommand(commandData.JournalData[JournalKeys.DynPathKey], forceManualRun));
dynamoViewModel.ShowStartPage = false;
}
}
//If we have information about the nodes and their values we want to push those values after the file is opened.
if (commandData.JournalData.ContainsKey(JournalKeys.ModelNodesInfo))
{
try
{
var allNodesInfo = JsonConvert.DeserializeObject <List <Dictionary <string, string> > >(commandData.JournalData[JournalKeys.ModelNodesInfo]);
if (allNodesInfo != null)
{
foreach (var nodeInfo in allNodesInfo)
{
if (nodeInfo.ContainsKey(JournalNodeKeys.Id) &&
nodeInfo.ContainsKey(JournalNodeKeys.Name) &&
nodeInfo.ContainsKey(JournalNodeKeys.Value))
{
var modelCommand = new DynamoModel.UpdateModelValueCommand(nodeInfo[JournalNodeKeys.Id],
nodeInfo[JournalNodeKeys.Name],
nodeInfo[JournalNodeKeys.Value]);
modelCommand.Execute(revitDynamoModel);
}
}
}
}
catch
{
Console.WriteLine("Exception while trying to update nodes with new values");
}
}
//If we are in automation mode the model will run anyway (on the main thread
//without the idle loop) regardless of the DynPathExecuteKey.
if (!isAutomationMode && commandData.JournalData.ContainsKey(JournalKeys.DynPathExecuteKey))
{
bool executePath = false;
bool.TryParse(commandData.JournalData[JournalKeys.DynPathExecuteKey], out executePath);
if (executePath)
{
HomeWorkspaceModel modelToRun = revitDynamoModel.CurrentWorkspace as HomeWorkspaceModel;
if (modelToRun != null)
{
modelToRun.Run();
return;
}
}
}
}
}
public Result ExecuteCommand(DynamoRevitCommandData commandData)
{
var startupTimer = Stopwatch.StartNew();
if (ModelState == RevitDynamoModelState.StartedUIless)
{
if (CheckJournalForKey(commandData, JournalKeys.ShowUiKey, true) ||
CheckJournalForKey(commandData, JournalKeys.ModelShutDownKey))
{
//When we move from UIless to UI we prefer to start with a fresh revitDynamoModel
//in order to benefit from a startup sequence similar to Dynamo Revit UI launch.
//Also there might be other situations which demand a new revitDynamoModel.
//In order to be able to address them we process ModelShutDownKey.
//An example of this situation is when you have a revitDynamoModel already started and you switch
//the document in Revit. Since revitDynamoModel is well connected to the previous document we need to
//shut it down and start a new one in order to able to run a graph in the new document.
revitDynamoModel.ShutDown(false);
ModelState = RevitDynamoModelState.NotStarted;
}
else
{
TryOpenAndExecuteWorkspaceInCommandData(commandData);
return(Result.Succeeded);
}
}
if (ModelState == RevitDynamoModelState.StartedUI)
{
TryOpenAndExecuteWorkspaceInCommandData(commandData);
return(Result.Succeeded);
}
HandleDebug(commandData);
InitializeCore(commandData);
//subscribe to the assembly load
AppDomain.CurrentDomain.AssemblyLoad += AssemblyLoad;
try
{
extCommandData = commandData;
UpdateSystemPathForProcess();
// create core data models
revitDynamoModel = InitializeCoreModel(extCommandData);
revitDynamoModel.UpdateManager.RegisterExternalApplicationProcessId(Process.GetCurrentProcess().Id);
revitDynamoModel.Logger.Log("SYSTEM", string.Format("Environment Path:{0}", Environment.GetEnvironmentVariable("PATH")));
// handle initialization steps after RevitDynamoModel is created.
revitDynamoModel.HandlePostInitialization();
ModelState = RevitDynamoModelState.StartedUIless;
// show the window
if (CheckJournalForKey(extCommandData, JournalKeys.ShowUiKey, true))
{
dynamoViewModel = InitializeCoreViewModel(revitDynamoModel);
// Let the host (e.g. Revit) control the rendering mode
var save = RenderOptions.ProcessRenderMode;
InitializeCoreView().Show();
RenderOptions.ProcessRenderMode = save;
revitDynamoModel.Logger.Log(Dynamo.Applications.Properties.Resources.WPFRenderMode + RenderOptions.ProcessRenderMode.ToString());
ModelState = RevitDynamoModelState.StartedUI;
// Disable the Dynamo button to prevent a re-run
DynamoRevitApp.DynamoButtonEnabled = false;
}
//foreach preloaded exception send a notification to the Dynamo Logger
//these are messages we want the user to notice.
preLoadExceptions.ForEach(x => revitDynamoModel.Logger.LogNotification
(revitDynamoModel.GetType().ToString(),
x.GetType().ToString(),
DynamoApplications.Properties.Resources.MismatchedAssemblyVersionShortMessage,
x.Message));
TryOpenAndExecuteWorkspaceInCommandData(extCommandData);
//unsubscribe to the assembly load
AppDomain.CurrentDomain.AssemblyLoad -= AssemblyLoad;
Analytics.TrackStartupTime("DynamoRevit", startupTimer.Elapsed, ModelState.ToString());
}
catch (Exception ex)
{
// notify instrumentation
Analytics.TrackException(ex, true);
MessageBox.Show(ex.ToString());
DynamoRevitApp.DynamoButtonEnabled = true;
//If for some reason Dynamo has crashed while startup make sure the Dynamo Model is properly shutdown.
if (revitDynamoModel != null)
{
revitDynamoModel.ShutDown(false);
revitDynamoModel = null;
}
return(Result.Failed);
}
return(Result.Succeeded);
}
