From 2509672fa3ebc042af215943e61bcbdfe871f804 Mon Sep 17 00:00:00 2001
From: Jan D''Orgeville <jdorgeville@spiria.com>
Date: Tue, 5 Jun 2018 11:23:26 -0400
Subject: [PATCH 1/4] proposal

---
 .../DynamoRevitVersionSelector.csproj         |  30 +-
 .../DynamoVersionSelector.xaml                |  15 -
 .../DynamoVersionSelector.xaml.cs             |  26 --
 .../DynamoRevitVersionSelector/Product.cs     | 123 ++++++
 .../ProductsManager.cs                        | 150 +++++++
 .../Properties/Resources.Designer.cs          |  50 ++-
 .../Properties/Resources.en-US.resx           |  35 +-
 .../Properties/Resources.resx                 |  35 +-
 .../Resources/dynamo_32x32.png                | Bin 4196 -> 0 bytes
 .../Resources/dynamo_setting_32x32.png        | Bin 0 -> 3421 bytes
 .../Tools/ImageConversion.cs                  |  68 ++++
 .../Tools/Presistence.cs                      | 138 +++++++
 .../DynamoRevitVersionSelector/Tools/UI.cs    | 147 +++++++
 .../VersionSelectorApp.cs                     | 383 +-----------------
 .../VersionSelectorButton.cs                  |  85 ++++
 .../DynamoRevitVersionSelector/logo_about.png | Bin 4342 -> 0 bytes
 16 files changed, 827 insertions(+), 458 deletions(-)
 delete mode 100644 src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml
 delete mode 100644 src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/Product.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
 delete mode 100644 src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
 delete mode 100644 src/Legacy/DynamoRevitVersionSelector/logo_about.png

diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
index 6a4bb2446f..1864333e7c 100644
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
+++ b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
@@ -35,14 +35,18 @@
   <ItemGroup>
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
-    <Reference Include="RevitAPI">
-      <HintPath>$(REVITAPI)\RevitAPI.dll</HintPath>
+    <Reference Include="AdWindows">
+      <HintPath>$(REVITAPI)\AdWindows.dll</HintPath>
       <Private>False</Private>
     </Reference>
     <Reference Include="RevitAPIUI">
       <HintPath>$(REVITAPI)\RevitAPIUI.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="RevitAPI">
+      <HintPath>$(REVITAPI)\RevitAPI.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
@@ -54,6 +58,8 @@
     <Compile Include="$(SolutionDir)AssemblySharedInfoGenerator\AssemblySharedInfo.cs">
       <Link>Properties\AssemblySharedInfo.cs</Link>
     </Compile>
+    <Compile Include="Product.cs" />
+    <Compile Include="ProductsManager.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
@@ -64,21 +70,12 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.en-US.resx</DependentUpon>
     </Compile>
+    <Compile Include="Tools\ImageConversion.cs" />
+    <Compile Include="Tools\Presistence.cs" />
+    <Compile Include="Tools\UI.cs" />
     <Compile Include="VersionSelectorApp.cs" />
-    <Compile Include="DynamoVersionSelector.xaml.cs">
-      <DependentUpon>DynamoVersionSelector.xaml</DependentUpon>
-    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Page Include="DynamoVersionSelector.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="logo_about.png" />
-    <None Include="Resources\dynamo_32x32.png" />
+    <Compile Include="VersionSelectorButton.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
@@ -90,6 +87,9 @@
       <LastGenOutput>Resources.en-US.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\dynamo_setting_32x32.png" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml b/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml
deleted file mode 100644
index 137a9f46ad..0000000000
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml
+++ /dev/null
@@ -1,15 +0,0 @@
-<Window x:Class="Dynamo.Applications.DynamoVersionSelector"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
-             mc:Ignorable="d" 
-             Height="240" Width="300">
-    <Grid>
-        <StackPanel Margin="5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="Auto">
-            <Image Source="/DynamoRevitVersionSelector;component/logo_about.png" Height="128" Width="128"></Image>
-            <TextBlock HorizontalAlignment="Center" Margin="5" Text="Choose a version of Dynamo."></TextBlock>
-            <ComboBox Name="VersionDropDown" Margin="5" ItemsSource="{Binding Versions}"></ComboBox>
-        </StackPanel>
-    </Grid>
-</Window>
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs b/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs
deleted file mode 100644
index 40dbe0c4d9..0000000000
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-
-namespace Dynamo.Applications
-{
-    /// <summary>
-    /// Interaction logic for DynamoVersionSelector.xaml
-    /// </summary>
-    public partial class DynamoVersionSelector : Window
-    {
-        public DynamoVersionSelector()
-        {
-            InitializeComponent();
-        }
-    }
-}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Product.cs b/src/Legacy/DynamoRevitVersionSelector/Product.cs
new file mode 100644
index 0000000000..afb2dddfc3
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Product.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Dynamo.Applications
+{
+    /// <summary>
+    /// A Dyanmo product definition
+    /// </summary>
+    internal class Product
+    {
+        #region Statics
+        /// <summary>
+        /// A way to says "plz keep using the lastest installed version available".
+        /// This should be the default value / lazy case (think if the end-user never use this DynamoRevitSelector facility).
+        /// We assume, that if the end-user selects explicitly the lastest version, then he'll keep follow tatest version
+        /// </summary>
+        public static readonly Version LASTESTDYNAMO = null;
+
+        /// <summary>
+        /// Dynamo product's assembly should always define the same type name
+        /// </summary>
+        public static readonly String DYNAMO_TYPENAME = "Dynamo.Applications.DynamoRevitApp";
+        #endregion
+
+        #region Accessors
+        /// <summary>
+        /// Version
+        /// </summary>
+        public Version Version
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Asssembly Path (i.e. "DynamoRevitDS.dll" location), maybe null
+        /// </summary>
+        public string AsssemblyPath
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Flag to say that this product is currently used
+        /// </summary>
+        public bool isCurrent
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// How to describe this product in UI (Title)
+        /// </summary>
+        public string Title
+        {
+            get
+            {
+                var msg = isCurrent ? Resources.DynamoCurrentVersionText : Resources.DynamoVersionText;
+                return string.Format(msg, Version.ToString(4));
+            }
+        }
+
+        /// <summary>
+        /// How to describe this product in (Sub Title)
+        /// </summary>
+        public string SubTitle
+        {
+            get; set;
+        }
+        #endregion
+
+        /// <summary>
+        /// Generic contructor
+        /// </summary>
+        public Product(Version version)
+        {
+            Version = version;
+        }
+
+        /// <summary>
+        /// Contructor, for a full defined product
+        /// </summary>
+        public Product(Version version, string assemblyPath, string installFolder)
+        {
+            Version = version;
+            AsssemblyPath = assemblyPath;
+            SubTitle = installFolder;
+        }
+
+        /// <summary>
+        /// Create a class instance from Assembly, exception needs to be properly handled
+        /// </summary>
+        /// <exception cref="System.ArgumentException">Thrown when Asssembly from AsssemblyPath can't be Loaded</exception>
+        /// <exception cref="System.MethodAccessException">Thrown when method can't be Access</exception>
+        public Object CreateInstance()
+        {
+            Assembly asm;
+            try
+            {
+                asm = Assembly.LoadFrom(AsssemblyPath);
+            }
+            catch (Exception)
+            {
+                throw new System.ArgumentException($"AsssemblyPath '{AsssemblyPath}', can't be loaded");
+            }
+            try
+            {
+                return asm.CreateInstance(DYNAMO_TYPENAME);
+            }
+            catch (Exception)
+            {
+                throw new System.MethodAccessException($"AsssemblyPath '{AsssemblyPath}', can't be access to '{DYNAMO_TYPENAME}'");
+            }
+        }
+    }
+
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
new file mode 100644
index 0000000000..b74d6b3c22
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Dynamo.Applications
+{
+    internal class ProductsManager
+    {
+
+        #region Statics
+        /// <summary>
+        /// Check if a Product is currently loaded in Current Application Domain
+        /// </summary>
+        /// <param name="version">If a product is loaded, provides its version.</param>
+        /// <returns>True if a Dynamo product is currently loaded</returns>
+        public static bool IsProductLoaded(ref Version version)
+        {
+            Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (Assembly asm in asms)
+            {
+                if (asm.GetType(Product.DYNAMO_TYPENAME) != null)
+                {
+                    version = asm.GetName().Version;
+                    return true;
+                }
+            }
+            return false;
+        }
+        #endregion
+
+        #region Accessors
+        /// <summary>
+        /// Accessor to the list of Dyanmo Product, the list is sorted in a way that .first() is
+        /// the most recent one
+        /// </summary>
+        public List<Product> List
+        {
+            get {
+                var list = mProducts.Values.ToList();
+                return list.OrderByDescending(x => x.Version).ToList();
+            }
+        }
+
+        /// <summary>
+        /// Number of Dyanmo Products available
+        /// </summary>
+        public int Count
+        {
+            get { return mProducts.Count; }
+        }
+
+        /// <summary>
+        /// Revit Version
+        /// </summary>
+        public string RevitVersion {
+            get; private set;
+        }
+        #endregion
+
+        protected UIControlledApplication uiControlledApplication;
+        protected Dictionary<Version, Product> mProducts;
+
+        /// <summary>
+        /// Contructor
+        /// </summary>
+        public ProductsManager(UIControlledApplication application)
+        {
+            uiControlledApplication = application;
+            RevitVersion = application.ControlledApplication.VersionNumber;
+            var revitFolder = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
+            var debugPath = revitFolder.Parent.FullName;
+            var dynamoProducts = FindDynamoRevitInstallations(debugPath);
+            mProducts = new Dictionary<Version, Product>();
+            foreach (var p in dynamoProducts)
+            {
+                if (p.Version < new Version(0, 7))
+                    continue; //0.6.3 and older version not supported for Revit2015 onwards
+                if (!File.Exists(p.AsssemblyPath))
+                    continue; // .DLL do not exist
+                mProducts.Add(p.Version, p);
+            }
+        }
+
+        protected IEnumerable<Product> FindDynamoRevitInstallations(string debugPath)
+        {
+            // Installation enumeration is based on LocateDynamoInstallations() static method of 'DynamoInstallDetective.dll'
+            var assembly = Assembly.LoadFrom(Path.Combine(debugPath, "DynamoInstallDetective.dll"));
+            var type = assembly.GetType("DynamoInstallDetective.Utilities");
+            var LocateDynamoInstallations = type.GetMethod("LocateDynamoInstallations", BindingFlags.Public | BindingFlags.Static);
+            if (LocateDynamoInstallations == null)
+            {
+                throw new MissingMethodException("Method 'DynamoInstallDetective.Utilities.LocateDynamoInstallations' not found");
+            }
+
+            // Where search for "DynamoRevitDS.dll" products which follow this Pattern:
+            Func<string, string> fileLocator = p => Path.Combine(p, string.Format("Revit_{0}", RevitVersion), "DynamoRevitDS.dll");
+
+            // Invoke LocateDynamoInstallations
+            var methodParams = new object[] { debugPath, fileLocator };
+            var installs = LocateDynamoInstallations.Invoke(null, methodParams) as IEnumerable;
+            if (null == installs)
+                return null;
+
+            // Enumeration return
+            return
+                installs.Cast<KeyValuePair<string, Tuple<int, int, int, int>>>()
+                    .Select(
+                        p => new Product(new Version(p.Value.Item1, p.Value.Item2, p.Value.Item3, p.Value.Item4), fileLocator(p.Key), p.Key)
+                );
+        }
+
+        /// <summary>
+        /// Check if a specific Product is currently loaded
+        /// </summary>
+        public void Load(Version version)
+        {
+            // Retreived product
+            var product = (version == Product.LASTESTDYNAMO) ? this.List.First() : mProducts[version];
+
+            // Is a dynamo product already loaded ?
+            Version currVersion = Product.LASTESTDYNAMO;
+            if (IsProductLoaded(ref currVersion))
+            {
+                var popup = new TaskDialog(Resources.DynamoVersions);
+                popup.MainInstruction = Resources.DynamoVersionSelection;
+                if (product.Version == currVersion)
+                {
+                    popup.MainContent = String.Format(Resources.ProductLoaded, product.Version);
+                }
+                else
+                {
+                    popup.MainContent = String.Format(Resources.ProductNeedToRestartRevit, product.Version);
+                }
+                popup.Show();
+                return;
+            }
+            
+            // Start Dyanmo product
+            var inst = product.CreateInstance();
+            var OnStartup = inst.GetType().GetMethod("OnStartup");
+            OnStartup.Invoke(inst, new object[] { uiControlledApplication });
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
index 7a09138cff..081e98f2f5 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
@@ -63,13 +63,22 @@ internal Resources() {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
-        internal static System.Drawing.Bitmap dynamo_32x32 {
+        internal static System.Drawing.Bitmap dynamo_setting_32x32 {
             get {
-                object obj = ResourceManager.GetObject("dynamo_32x32", resourceCulture);
+                object obj = ResourceManager.GetObject("dynamo_setting_32x32", resourceCulture);
                 return ((System.Drawing.Bitmap)(obj));
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Dynamo {0} (current).
+        /// </summary>
+        internal static string DynamoCurrentVersionText {
+            get {
+                return ResourceManager.GetString("DynamoCurrentVersionText", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Dynamo Version.
         /// </summary>
@@ -98,39 +107,50 @@ internal static string DynamoVersionText {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit.
+        ///   Looks up a localized string similar to Dynamo [{0}] is selected..
         /// </summary>
-        internal static string DynamoVersionTooltip {
+        internal static string ProductLoaded {
             get {
-                return ResourceManager.GetString("DynamoVersionTooltip", resourceCulture);
+                return ResourceManager.GetString("ProductLoaded", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Dynamo version {0} will be loaded after Revit restart..
+        ///   Looks up a localized string similar to Dynamo [{0}] is selected.
+        ///
+        ///Please restart Revit to use it..
         /// </summary>
-        internal static string RestartMessage {
+        internal static string ProductNeedToRestartRevit {
             get {
-                return ResourceManager.GetString("RestartMessage", resourceCulture);
+                return ResourceManager.GetString("ProductNeedToRestartRevit", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Multiple version of Dynamo installation found on this system.
-        ///Please select the Dynamo version you wish to run..
+        ///   Looks up a localized string similar to Version Selection.
         /// </summary>
-        internal static string VersionSelectionContent {
+        internal static string VersionSelectionBtnText {
             get {
-                return ResourceManager.GetString("VersionSelectionContent", resourceCulture);
+                return ResourceManager.GetString("VersionSelectionBtnText", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Visual Programming.
+        ///   Looks up a localized string similar to Change active Dynamo version.
         /// </summary>
-        internal static string VisualProgramming {
+        internal static string VersionSelectionBtnToolTip {
             get {
-                return ResourceManager.GetString("VisualProgramming", resourceCulture);
+                return ResourceManager.GetString("VersionSelectionBtnToolTip", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Multiple version of Dynamo installation found on this system.
+        ///Please select the Dynamo version you wish to run..
+        /// </summary>
+        internal static string VersionSelectionContent {
+            get {
+                return ResourceManager.GetString("VersionSelectionContent", resourceCulture);
             }
         }
     }
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
index 5e9192afb9..905541f0ff 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
@@ -123,19 +123,6 @@
   <data name="DynamoVersionText" xml:space="preserve">
     <value>Dynamo {0}</value>
   </data>
-  <data name="RestartMessage" xml:space="preserve">
-    <value>Dynamo version {0} will be loaded after Revit restart.</value>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="dynamo_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\dynamo_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="DynamoVersionTooltip" xml:space="preserve">
-    <value>Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit</value>
-  </data>
-  <data name="VisualProgramming" xml:space="preserve">
-    <value>Visual Programming</value>
-  </data>
   <data name="DynamoVersionSelection" xml:space="preserve">
     <value>Dynamo Version Selection</value>
   </data>
@@ -143,4 +130,26 @@
     <value>Multiple version of Dynamo installation found on this system.
 Please select the Dynamo version you wish to run.</value>
   </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="dynamo_setting_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dynamo_setting_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="ProductNeedToRestartRevit" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.
+
+Please restart Revit to use it.</value>
+    <comment>multiline text</comment>
+  </data>
+  <data name="VersionSelectionBtnText" xml:space="preserve">
+    <value>Version Selection</value>
+  </data>
+  <data name="VersionSelectionBtnToolTip" xml:space="preserve">
+    <value>Change active Dynamo version</value>
+  </data>
+  <data name="ProductLoaded" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.</value>
+  </data>
+  <data name="DynamoCurrentVersionText" xml:space="preserve">
+    <value>Dynamo {0} (current)</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
index 5e9192afb9..905541f0ff 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
@@ -123,19 +123,6 @@
   <data name="DynamoVersionText" xml:space="preserve">
     <value>Dynamo {0}</value>
   </data>
-  <data name="RestartMessage" xml:space="preserve">
-    <value>Dynamo version {0} will be loaded after Revit restart.</value>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="dynamo_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\dynamo_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="DynamoVersionTooltip" xml:space="preserve">
-    <value>Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit</value>
-  </data>
-  <data name="VisualProgramming" xml:space="preserve">
-    <value>Visual Programming</value>
-  </data>
   <data name="DynamoVersionSelection" xml:space="preserve">
     <value>Dynamo Version Selection</value>
   </data>
@@ -143,4 +130,26 @@
     <value>Multiple version of Dynamo installation found on this system.
 Please select the Dynamo version you wish to run.</value>
   </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="dynamo_setting_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dynamo_setting_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="ProductNeedToRestartRevit" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.
+
+Please restart Revit to use it.</value>
+    <comment>multiline text</comment>
+  </data>
+  <data name="VersionSelectionBtnText" xml:space="preserve">
+    <value>Version Selection</value>
+  </data>
+  <data name="VersionSelectionBtnToolTip" xml:space="preserve">
+    <value>Change active Dynamo version</value>
+  </data>
+  <data name="ProductLoaded" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.</value>
+  </data>
+  <data name="DynamoCurrentVersionText" xml:space="preserve">
+    <value>Dynamo {0} (current)</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png b/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png
deleted file mode 100644
index 342516405a691b7f18853249fb6c136cce8e12d2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4196
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
YeE)~POiE>bJPti|_~5ZmzWCk$0K7Asr2qf`

diff --git a/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png b/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png
new file mode 100644
index 0000000000000000000000000000000000000000..285e4bc4f9776f85e4dae2805ec747854e7c76dd
GIT binary patch
literal 3421
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

literal 0
HcmV?d00001

diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs
new file mode 100644
index 0000000000..fe166fcc2d
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class ImageConversion
+    {
+        /// <summary>
+        /// Converts a <see cref="System.Drawing.Image"/> into <see cref=" System.Windows.Media.ImageSource"/>.
+        /// </summary>
+        /// <param name="source">The source image.</param>
+        /// <returns>A BitmapSource</returns>
+        public static System.Windows.Media.ImageSource ToBitmapSource(this System.Drawing.Image source)
+        {
+            System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(source);
+
+            var bitSrc = bitmap.ToBitmapSource();
+
+            bitmap.Dispose();
+            bitmap = null;
+
+            return bitSrc;
+        }
+
+        /// <summary>
+        /// Converts a <see cref="System.Drawing.Bitmap"/> into <see cref="System.Windows.Media.ImageSource"/>.
+        /// </summary>
+        /// <remarks>Uses GDI to do the conversion. Hence the call to the marshalled DeleteObject.
+        /// </remarks>
+        /// <param name="source">The source bitmap.</param>
+        /// <returns>A BitmapSource</returns>
+        public static System.Windows.Media.ImageSource ToBitmapSource(this System.Drawing.Bitmap source)
+        {
+            System.Windows.Media.ImageSource bitSrc = null;
+
+            var hBitmap = source.GetHbitmap();
+
+            try
+            {
+                bitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
+                    hBitmap,
+                    IntPtr.Zero,
+                    System.Windows.Int32Rect.Empty,
+                    System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
+            }
+            catch (System.ComponentModel.Win32Exception)
+            {
+                bitSrc = null;
+            }
+            finally
+            {
+                NativeMethods.DeleteObject(hBitmap);
+            }
+
+            return bitSrc;
+        }
+
+        /// <summary>
+        /// FxCop requires all Marshalled functions to be in a class called NativeMethods.
+        /// </summary>
+        internal static class NativeMethods
+        {
+            [DllImport("gdi32.dll")]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static extern bool DeleteObject(IntPtr hObject);
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
new file mode 100644
index 0000000000..c209039504
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
@@ -0,0 +1,138 @@
+using System;
+using Microsoft.Win32;
+using System.Security.AccessControl;
+using System.Diagnostics;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class Presistence
+    {
+        /// <summary>
+        /// Dynamo Registry Key which may be null if couldn't be created or open
+        /// Typical: 'HKEY_CURRENT_USER\SOFTWARE\Dynamo'
+        /// </summary>
+        private static RegistryKey RegKey = null;
+        
+        /// <summary>
+        /// Dynamo Registry Key Security (i.e. access rights)
+        /// </summary>
+        private static RegistrySecurity RS = null;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        static Presistence()
+        {
+            const string KeyName = @"SOFTWARE\Dynamo";
+            string user = Environment.UserDomainName + "\\" + Environment.UserName;
+            RS = new RegistrySecurity();
+            RS.AddAccessRule(new RegistryAccessRule(user,
+                RegistryRights.FullControl,
+                InheritanceFlags.None,
+                PropagationFlags.None,
+                AccessControlType.Allow));
+            RegKey = OpenOrCreateSubKey(Registry.CurrentUser, KeyName, RS);
+            if (RegKey != null) RegKey.Close();
+            
+            // keep it open
+            RegKey = OpenOrCreateSubKey(Registry.CurrentUser, KeyName, RS);
+        }
+
+        private static readonly string VERSION = @"ActiveVersion";
+
+        public static Version ActiveVersion {
+            /// <summary>
+            /// Returns last dynamo version persisted
+            /// or null if no version was ever selected
+            /// </summary>
+            get
+            {
+                Object obj = null;
+                GetValue(RegKey, VERSION, ref obj);
+                if (obj == null) return null;
+                if (obj.GetType() == typeof(String)) return new Version((string)obj);
+                return null;
+            }
+
+            /// <summary>
+            /// Persist current Dynamo Version selected
+            /// </summary>
+            set
+            {
+                if (value == null)
+                {
+                    SetValue(RegKey, VERSION, null, RS);
+                }
+                else
+                {
+                    SetValue(RegKey, VERSION, value.ToString(4), RS);
+                }
+            }
+        }
+
+        #region SafeVersionOfRegistry
+        /// <summary>
+        /// Safetly Open or Create a SubKey
+        /// </summary>
+        private static RegistryKey OpenOrCreateSubKey(RegistryKey key, string keyName, RegistrySecurity rs) {
+            RegistryKey rk = null;
+            /* open if exist */
+            try {
+                rk = key.OpenSubKey(keyName, true);
+            } catch (Exception e) {
+                Debug.Write(e);
+            }
+            if (rk != null) return rk;
+
+            /* create one otherwise */
+            try
+            {
+                rk = key.CreateSubKey(keyName, RegistryKeyPermissionCheck.Default, rs);
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+            return rk;
+        }
+
+        /// <summary>
+        /// Safe version of SetValue
+        /// </summary>
+        private static void SetValue(RegistryKey key, String name, object value, RegistrySecurity rs)
+        {
+            try
+            {
+                if (value == null)
+                {
+                    key.DeleteValue(name);
+                }
+                else
+                {
+                    key.SetValue(name, value);
+                }
+                
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+        }
+
+        /// <summary>
+        /// Safe version of GetValue
+        /// </summary>
+        private static void GetValue(RegistryKey key, String name, ref object obj)
+        {
+            try
+            {
+                obj = key.GetValue(name);
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+        }
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
new file mode 100644
index 0000000000..cc1485a827
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using adWin = Autodesk.Windows;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class UI
+    {
+        static UI() {
+            adWin.ComponentManager.UIElementActivated += new EventHandler<adWin.UIElementActivatedEventArgs>(OnUIEvent);
+        }
+
+        // UI Event Handling
+        private delegate void EventHandler(object sender, adWin.UIElementActivatedEventArgs e);
+        private static Dictionary<string, EventHandler> listener = new Dictionary<string, EventHandler>();
+        private static void OnUIEvent(object sender, adWin.UIElementActivatedEventArgs e)
+        {
+            if (e == null) return;
+            if (e.Item == null) return;
+            if (e.Item.Id == null) return;
+            if (listener.ContainsKey(e.Item.Id)) listener[e.Item.Id](sender, e);
+        }
+
+        ///
+        /// <summary>
+        ///     Get all the custom Panels on a designated Revit tab.
+        /// </summary>
+        /// 
+        /// <param name="tabName">
+        ///     The name of the tab on which the panels are located.
+        /// </param>
+        /// 
+        /// <remarks>
+        ///     With official UIControlledApplication.GetRibbonPanels(string tabName),
+        ///     Built-in panels would not be included. tabName would need be the name of one of the
+        ///     tabs added by Autodesk.Revit.UI.UIApplication.CreateRibbonTab(System.String).
+        ///     However thanks to Jeremy Tammik who brings a workaround in his blog post
+        ///     http://thebuildingcoder.typepad.com/blog/2013/02/adding-a-btn-to-existing-ribbon-panel.html
+        /// </remarks>  
+        public static adWin.RibbonPanelCollection GetRibbonPanels(string tabName)
+        {
+            adWin.RibbonControl ribbon = adWin.ComponentManager.Ribbon;
+            foreach (adWin.RibbonTab tab in ribbon.Tabs)
+            {
+                if (tab.Id == tabName)
+                {
+                    return tab.Panels;
+                }
+            }
+            return new adWin.RibbonPanelCollection(); // empty collection
+        }
+
+
+        ///
+        /// <summary>
+        ///     This class contains information necessary to construct a push btn in the Ribbon.
+        /// </summary>
+        public class PushButtonData
+        {
+            protected adWin.RibbonButton btn;
+
+            public adWin.RibbonButton Source
+            {
+                get { return btn; }
+            }
+
+            public String Text
+            {
+                get { return btn.Text; }
+                set { btn.Text = value; }
+            }
+
+            public String ToolTip
+            {
+                get { return (String)btn.ToolTip; }
+                set { btn.ToolTip = value; }
+            }
+
+            public System.Drawing.Bitmap Image
+            {
+                set
+                {
+                    btn.Image = ImageConversion.ToBitmapSource(value);
+                    btn.LargeImage = ImageConversion.ToBitmapSource(value);
+                    btn.ShowImage = true;
+                }
+            }
+
+            public Boolean IsEnabled
+            {
+                get { return btn.IsEnabled; }
+                set { btn.IsEnabled = value; }
+            }
+
+            public Boolean IsVisible
+            {
+                get { return btn.IsVisible; }
+                set { btn.IsVisible = value; }
+            }
+
+            public delegate void OnClickEventHandler();
+            public event OnClickEventHandler OnClickEvent;
+            private void OnUIEvent(object sender, adWin.UIElementActivatedEventArgs e)
+            {
+                OnClickEvent();
+            }
+
+            ///
+            /// <summary>
+            ///     Constructs a new instance of PushButtonData.
+            /// </summary>
+            /// 
+            /// <param name="id">
+            ///     Unique identifier (like "ID_MY_BUTTON")
+            /// </param>
+            /// <param name="name">
+            ///     The internal name of the new btn.
+            /// </param>
+            /// <param name="text">
+            ///     The user visible text seen on the new btn.
+            /// </param>
+            /// 
+            /// <exception cref="System.ArgumentNullException">Thrown when null is passed for one or more arguments</exception>
+            /// <exception cref="System.ArgumentException">Thrown when an empty string is passed for one or more arguments</exception>
+            public PushButtonData(string Id, string name = "", string text = "")
+            {
+                if (Id == null) throw new ArgumentNullException("Id", "Id shouldn't be null");
+                if (String.IsNullOrWhiteSpace(Id)) throw new ArgumentException("Id", "name shouldn't be empty");
+                if (String.IsNullOrWhiteSpace(name)) name = Id;
+                if (String.IsNullOrWhiteSpace(text)) text = name;
+                btn = new adWin.RibbonButton();
+                btn.IsEnabled = true;
+                btn.IsVisible = true;
+                btn.Name = name;
+                btn.Text = text;
+                btn.Id = Id;
+                btn.Size = adWin.RibbonItemSize.Large;
+                btn.Orientation = System.Windows.Controls.Orientation.Vertical;
+                btn.ShowImage = false;
+                btn.ShowText = true;
+                btn.GroupLocation = Autodesk.Private.Windows.RibbonItemGroupLocation.Last;
+                btn.IsCheckable = true;
+                listener.Add(btn.Id, this.OnUIEvent);
+            }
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
index 9436b804aa..9e06a653a2 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
@@ -17,393 +17,54 @@
 
 namespace Dynamo.Applications
 {
-    internal struct DynamoProduct
-    {
-        public string InstallLocation;
-        public Version VersionInfo;
-
-        public string VersionString
-        {
-            get
-            {
-                return string.Format(
-                    @"Dynamo {0}", VersionInfo.ToString(4));
-            }
-        }
-    }
-
     [Transaction(TransactionMode.Manual)]
     [Regeneration(RegenerationOption.Manual)]
     public class VersionLoader : IExternalApplication
     {
-        private static UIControlledApplication uiControlledApplication;
-        private AddInCommandBinding dynamoCommand;
-        private AddInCommandBinding dynamoPlayerCommand;
-        internal List<DynamoProduct> Products { get; private set; }
-        //PlaylistProducts represent a subset of available Dynamo Products who are supporting Playlist feature.        
-        private List<DynamoProduct> PlaylistProducts { get; set; }
-
-        //Minimum version requirements needed by Playlist feature for Dynamo and Revit.
-        private const int MinDynamoMajorVersionForPlaylist = 1;
-        private const int MinDynamoMinorVersionForPlaylist = 2;
-
-        internal static string GetDynamoRevitPath(DynamoProduct product, string revitVersion)
-        {
-            if (product.VersionInfo < new Version(0, 7))
-                return string.Empty; //0.6.3 and older version not supported for Revit2015 onwards
-
-            return Path.Combine(product.InstallLocation, string.Format("Revit_{0}", revitVersion), "DynamoRevitDS.dll");
-        }
+        ProductsManager DynamoProducts;
 
         public Result OnStartup(UIControlledApplication application)
         {
-            uiControlledApplication = application;
-            var revitVersion = application.ControlledApplication.VersionNumber;
-
-            var revitFolder =
-                new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
-
-            var debugPath = revitFolder.Parent.FullName;
-            var dynamoProducts = FindDynamoRevitInstallations(debugPath, revitVersion);
-
-            Products = new List<DynamoProduct>();
-            PlaylistProducts = new List<DynamoProduct>();
-            foreach (var p in dynamoProducts)
+            // Find available Dyanmo Products
+            DynamoProducts = new ProductsManager(application);
+            if (DynamoProducts.Count == 0)
             {
-                var path = VersionLoader.GetDynamoRevitPath(p, revitVersion);
-                if (!File.Exists(path))
-                    continue;
-
-                Products.Add(p);
-
-                if (p.VersionInfo.Major >= MinDynamoMajorVersionForPlaylist
-                    && p.VersionInfo.Minor >= MinDynamoMinorVersionForPlaylist)
-                {
-                    PlaylistProducts.Add(p);
-                }
-            }
-
-            if (Products.Count == 0)
                 return Result.Failed;
-
-            Result preliminaryLoadResult = Result.Succeeded;
-
-            // If there are multiple versions installed, then do the command 
-            // binding to prompt for version selector task dialog for user to 
-            // select specific Dynamo version.
-            if (Products.Count > 1)
-            {
-                var dynamoCmdId = RevitCommandId.LookupCommandId("ID_VISUAL_PROGRAMMING_DYNAMO");
-                dynamoCommand = application.CreateAddInCommandBinding(dynamoCmdId);
-                dynamoCommand.CanExecute += canExecute;
-                dynamoCommand.BeforeExecuted += beforeExecuted;
-                dynamoCommand.Executed += executed;
-
-                if (PlaylistProducts.Count >= 1)
-                {
-                    var dynamoPlayerCmdId = RevitCommandId.LookupCommandId("ID_PLAYLIST_DYNAMO");
-                    if (dynamoPlayerCmdId != null)
-                    {
-                        dynamoPlayerCommand = application.CreateAddInCommandBinding(dynamoPlayerCmdId);
-                        dynamoPlayerCommand.CanExecute += canExecute;
-                        dynamoPlayerCommand.BeforeExecuted += beforeExecuted;
-                        dynamoPlayerCommand.Executed += executedPlaylist;
-                    }
-                }
             }
-            else //If only one product is installed load the Revit App directly
-            {
-                preliminaryLoadResult = loadProduct(Products.First(), revitVersion);
-            }
-
-            return preliminaryLoadResult;
-        }
 
-        void executed(object sender, ExecutedEventArgs e)
-        {
-            var product = PromptVersionSelectorDialog(Products);
-            if(product.HasValue)
-                LaunchDynamoCommand(product.Value, e);
-        }
-
-        private void executedPlaylist(object sender, ExecutedEventArgs e)
-        {
-            if (PlaylistProducts.Count == 0)
-                return;
-
-            DynamoProduct productToLaunch = PlaylistProducts.First();
-            if (PlaylistProducts.Count > 1)
+            // If multiple product are available then add a selection Button in the Ribbon
+            if (DynamoProducts.Count > 1)
             {
-                var product = PromptVersionSelectorDialog(PlaylistProducts);
-                if (product.HasValue)
-                {
-                    productToLaunch = product.Value;
-                }
+                var selectBtn = new VersionSelectorButton(application, DynamoProducts.List);
+                selectBtn.AddInRibbon();
+                selectBtn.OnVersionSelected += LoadDynamoProduct;
             }
 
-            LaunchDynamoCommand(productToLaunch, e, true);
-        }
-
-        void beforeExecuted(object sender, BeforeExecutedEventArgs e)
-        {
-            e.UsingCommandData = true;
-        }
-
-        void canExecute(object sender, CanExecuteEventArgs e)
-        {
-            e.CanExecute = e.ActiveDocument != null;
-        }
-
-        private Result loadProduct(DynamoProduct product, string revitVersion)
-        {
-            string loadPath = GetDynamoRevitPath(product, revitVersion);
-
-            if (String.IsNullOrEmpty(loadPath))
-                return Result.Failed;
-
-            var ass = Assembly.LoadFrom(loadPath);
-            var revitApp = ass.CreateInstance("Dynamo.Applications.DynamoRevitApp");
-            revitApp.GetType().GetMethod("OnStartup").Invoke(revitApp, new object[] { uiControlledApplication });
-
-            return Result.Succeeded;
-        }
-
-        /// <summary>
-        /// Prompts for version selection task dialog
-        /// </summary>
-        /// <param name="availableProducts">Choice list of Dynamo Products available for selection</param>
-        /// <returns>DynamoProduct to launch or null</returns>
-        private DynamoProduct? PromptVersionSelectorDialog(List<DynamoProduct> availableProducts)
-        {
-            // Creates a Revit task dialog to communicate information to the user.
-            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
-            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
-            mainDialog.MainContent = Resources.VersionSelectionContent;
-
-            // Add commmandLink options to task dialog
-            int id = (int)TaskDialogCommandLinkId.CommandLink1;
-            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
-            //Get the default selection data
-            var selectorData = VersionSelectorData.ReadFromRegistry(revitVersion);
-            var selectedVersion = selectorData.SelectedVersion.ToString(2);
-            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
-            foreach (var item in availableProducts)
+            // Get Persisted Dyanmo Version (by default get latest)
+            Version activeVersion = Product.LASTESTDYNAMO;
+            try
             {
-                var versionText = String.Format(Resources.DynamoVersionText, item.VersionInfo.ToString(3));
-                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, versionText, item.InstallLocation);
-                if (item.VersionInfo.ToString(2) == selectedVersion)
-                    defaultResult = (TaskDialogResult)id;
-
-                id++;
+                activeVersion = Tools.Presistence.ActiveVersion;
             }
+            catch (Exception) { /* */ }
 
-            // Set common buttons and default button. If no CommonButton or CommandLink is added,
-            // task dialog will show a Close button by default
-            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
-            mainDialog.DefaultButton = defaultResult;
-
-            TaskDialogResult tResult = mainDialog.Show();
-            if (tResult == TaskDialogResult.Close)
-                return null;
-
-            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
-            return availableProducts[index];
+            return LoadDynamoProduct(activeVersion);
         }
 
-
-        /// <summary>
-        /// Launches specific version of Dynamo command
-        /// </summary>
-        /// <param name="product">DynamoProduct to launch</param>
-        /// <param name="e">Command executed event argument</param>
-        /// <param name="playlist">Launch the Playlist app or just Dynamo</param>
-        /// <returns>true for success</returns>
-        private bool LaunchDynamoCommand(DynamoProduct product, ExecutedEventArgs e,bool playlist = false)
-        {
-            if (uiControlledApplication == null)
-                throw new InvalidOperationException();
-
-            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
-            var path = GetDynamoRevitPath(product, revitVersion);
-            var data = new VersionSelectorData() { RevitVersion = revitVersion, SelectedVersion = product.VersionInfo };
-            data.WriteToRegistry();
-
-            //Initialize application
-            var ass = Assembly.LoadFrom(path);
-            var revitApp = ass.CreateInstance("Dynamo.Applications.DynamoRevitApp");
-            if (null == revitApp)
-                return false;
-            
-            //Remove the command binding, because now DynamoRevitApp will 
-            //do the command binding for DynamoRevit command.
-            RemoveCommandBinding();
-
-            var type = revitApp.GetType();
-            var result = type.GetMethod("OnStartup").Invoke(revitApp, new object[] { uiControlledApplication });
-            if ((Result)result != Result.Succeeded)
-                return false;
-
-            UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
-
-            if (!playlist)
-            {
-                //Invoke command
-                string message = string.Empty;
-                result = type.GetMethod("ExecuteDynamoCommand").Invoke(revitApp, new object[] { e.GetJournalData(), uiApp });
-                if ((Result)result != Result.Succeeded)
-                    return false;
-            }
-            else
+        private Result LoadDynamoProduct(Version version) {
+            // Start Dynamo Product
+            try
             {
-                //Dependent components have done a re-binding of Playlist command in order to be executed in their context.
-                //In order to lunch the Playlist we just need to post the command to the Revit application.
-                var dynamoPlayerCmdId = RevitCommandId.LookupCommandId("ID_PLAYLIST_DYNAMO");
-                if (dynamoPlayerCmdId != null)
-                    uiApp.PostCommand(dynamoPlayerCmdId);
+                DynamoProducts.Load(Tools.Presistence.ActiveVersion);
+                return Result.Succeeded;
             }
-
-            uiControlledApplication = null; //release application, no more needed.
-            return true;
+            catch (Exception) { /* */ }
+            return Result.Failed;
         }
 
         public Result OnShutdown(UIControlledApplication application)
         {
-            RemoveCommandBinding();
             return Result.Succeeded;
         }
-
-        private void RemoveCommandBinding()
-        {
-            if (null != dynamoCommand)
-            {
-                uiControlledApplication.RemoveAddInCommandBinding(dynamoCommand.RevitCommandId);
-                dynamoCommand.BeforeExecuted -= beforeExecuted;
-                dynamoCommand.CanExecute -= canExecute;
-                dynamoCommand.Executed -= executed;
-                dynamoCommand = null;
-            }
-
-            if (null != dynamoPlayerCommand)
-            {
-                uiControlledApplication.RemoveAddInCommandBinding(dynamoPlayerCommand.RevitCommandId);
-                dynamoPlayerCommand.BeforeExecuted -= beforeExecuted;
-                dynamoPlayerCommand.CanExecute -= canExecute;
-                dynamoPlayerCommand.Executed -= executedPlaylist;
-                dynamoPlayerCommand = null;
-            }                
-
-        }
-
-        private static IEnumerable<DynamoProduct> FindDynamoRevitInstallations(string debugPath, string revitVersion)
-        {
-            var assembly = Assembly.LoadFrom(Path.Combine(debugPath, "DynamoInstallDetective.dll"));
-            var type = assembly.GetType("DynamoInstallDetective.Utilities");
-
-            var installationsMethod = type.GetMethod(
-                "LocateDynamoInstallations",
-                BindingFlags.Public | BindingFlags.Static);
-
-            if (installationsMethod == null)
-            {
-                throw new MissingMethodException("Method 'DynamoInstallDetective.Utilities.LocateDynamoInstallations' not found");
-            }
-
-            Func<string, string> fileLocator =
-                p => Path.Combine(p, string.Format("Revit_{0}", revitVersion), "DynamoRevitDS.dll");
-
-            var methodParams = new object[] { debugPath, fileLocator };
-
-            var installs = installationsMethod.Invoke(null, methodParams) as IEnumerable;
-            if(null == installs)
-                return null;
-
-            return
-                installs.Cast<KeyValuePair<string, Tuple<int, int, int, int>>>()
-                    .Select(
-                        p => new DynamoProduct() { InstallLocation = p.Key, 
-                            VersionInfo = new Version(p.Value.Item1, p.Value.Item2, p.Value.Item3, p.Value.Item4) });
-        }
-
-    }
-
-    /// <summary>
-    /// VersionSelectorData: A class to keep the selected version data to be stored in registry.
-    /// </summary>
-    internal class VersionSelectorData
-    {
-        const string RegKey64 = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\";
-        
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public VersionSelectorData()
-        { 
-            ThisDynamoVersion = Assembly.GetExecutingAssembly().GetName().Version;
-        }
-
-        /// <summary>
-        /// Reads the version selection data for specific revit version from 
-        /// registry and returns a new VersionSelectorData.
-        /// </summary>
-        /// <param name="revitVersion">Revit version</param>
-        /// <returns>VersionSelectorData</returns>
-        public static VersionSelectorData ReadFromRegistry(string revitVersion)
-        {
-            var data = new VersionSelectorData() { RevitVersion = revitVersion };
-            data.SelectedVersion = data.ThisDynamoVersion; //Default initialization
-
-            try
-            {
-                var regKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
-                regKey = regKey.OpenSubKey(RegKey64);
-
-                var key = string.Format(@"Dynamo {0}.{1}", data.ThisDynamoVersion.Major, data.ThisDynamoVersion.Minor);
-                regKey = regKey.OpenSubKey(key);
-                if (regKey == null)
-                    return data;
-
-                var version = regKey.GetValue(data.RevitVersion);
-
-                Version selectedVersion = null;
-                if (Version.TryParse(version as string, out selectedVersion))
-                    data.SelectedVersion = selectedVersion;
-            }
-            catch (SystemException) { }
-
-            return data;
-        }
-
-        /// <summary>
-        /// Saves this data to Registry
-        /// </summary>
-        public void WriteToRegistry()
-        {
-            try
-            {
-                var regKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
-                regKey = regKey.OpenSubKey(RegKey64);
-
-                var key = string.Format(@"Dynamo {0}.{1}", ThisDynamoVersion.Major, ThisDynamoVersion.Minor);
-                regKey = regKey.OpenSubKey(key, true);
-                if(null != regKey)
-                    regKey.SetValue(RevitVersion, SelectedVersion.ToString(), RegistryValueKind.String);
-            }
-            catch (SystemException) { }
-        }
-
-        /// <summary>
-        /// Gets the version of this Dynamo
-        /// </summary>
-        public Version ThisDynamoVersion { get; private set; }
-
-        /// <summary>
-        /// Revit version string
-        /// </summary>
-        public string RevitVersion { get; set; }
-
-        /// <summary>
-        /// Gets the version of Dynamo that was selected to run.
-        /// </summary>
-        public Version SelectedVersion { get; set; }
     }
 }
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
new file mode 100644
index 0000000000..8b3831d1a4
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+
+namespace Dynamo.Applications
+{
+    internal class VersionSelectorButton
+    {
+        private List<Product> mProductList;
+        private UIControlledApplication uiControlledApplication;
+
+        public delegate Result OnVersionSelectedEventHandler(Version version);
+        public event OnVersionSelectedEventHandler OnVersionSelected;
+
+        public VersionSelectorButton(UIControlledApplication application, List<Product> ProductList)
+        {
+            uiControlledApplication = application;
+            mProductList = ProductList;
+        }
+
+        public void AddInRibbon()
+        {
+            foreach (var panel in Tools.UI.GetRibbonPanels("Manage"))
+            {
+                if(panel.Source.Id == "visualprogramming_shr")
+                {
+                    var btn = new Tools.UI.PushButtonData("ID_DYANMO_CHANGEVERSION");
+                    btn.Text = Resources.VersionSelectionBtnText;
+                    btn.ToolTip = Resources.VersionSelectionBtnToolTip;
+                    btn.Image = Resources.dynamo_setting_32x32;
+                    btn.OnClickEvent += OnClick;
+                    panel.Source.Items.Add(btn.Source);
+                }
+            }
+        }
+
+        private void OnClick()
+        {
+            // retreived current active version
+            Version latestVersion = mProductList.First().Version;
+            Version currentVersion = Tools.Presistence.ActiveVersion;
+            if (currentVersion == Product.LASTESTDYNAMO)
+                currentVersion = latestVersion;
+
+            // Creates a Revit task dialog to communicate information to the user.
+            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
+            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
+            mainDialog.MainContent = Resources.VersionSelectionContent;
+
+            // Add commmandLink options to task dialog
+            int id = (int)TaskDialogCommandLinkId.CommandLink1;
+            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
+            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
+            foreach (var item in mProductList)
+            {
+                item.isCurrent = (item.Version == currentVersion);
+                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, item.Title, item.SubTitle);
+                if (item.isCurrent) defaultResult = (TaskDialogResult)id;
+                id++;
+            }
+            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
+            mainDialog.DefaultButton = defaultResult;
+
+            TaskDialogResult tResult = mainDialog.Show();
+            if (tResult == TaskDialogResult.Close)
+                return;
+
+            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
+            try
+            {
+                var selectedVersion = mProductList[index].Version;
+                if (selectedVersion == latestVersion)
+                    selectedVersion = Product.LASTESTDYNAMO;
+
+                // Save Result
+                Tools.Presistence.ActiveVersion = selectedVersion;
+                OnVersionSelected(selectedVersion);
+            }
+            catch (Exception) { /* */ }
+
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/logo_about.png b/src/Legacy/DynamoRevitVersionSelector/logo_about.png
deleted file mode 100644
index 650d04700fec2344d4a781addba26d7478e78008..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4342
zcma)AS5T9I()|(w1PB<A-lV7yP`Y%aDMdkgks_cJl@6g9N&?b*2N6L)q*oyjkS<+{
z^csp96he^Rgx~xA&)oa4=bV?FIWv16b~jr8ktQuQJ2e0RwAxzt4F56uKLw@uhuwGW
zhW-&7^1eCJ$lVd?XXoVrsM@<fb>Pu<wR3VXbg;7z@EmYZ1ORxJ_B~Z&|M{)lAQw)b
zSABT_ct6toW~MCNz>Q{3h%ES#@vBNCZjCXmtwZ^d57VNuaU^7><a68gk7WfPOgIX=
z4xY=!RDTFHHR&wixn8tsx1vI+WWBy=EvBgzmCHi->f7q;LK->SKdE$jJGb<h<o4aC
zHHV;D_@zBJJ2#uKhk8dMW#e^Z`#jNGy>}7-9$-TV4%kBgHjs)2kVOAqq?I4)kIW&y
zQsKArQsYv#hfYGDk$%8(_IHP%(8Tla6-}!rbOGHc-n)U@iI;oge687lzZ?Fqa?96m
z+bd?W+b<9l${Er*?4nMvhu5$jcZIyVC|{JWFGax>)b*tV0nx3NkTsfOT<sg5`cRm=
z@PaD&0N#a4QQ3L67co?;5wH@HmZ5-;rmi)DhU)?q&(22LD4)!`{^Txm$YDd!kp?U~
zkjLq!_2db8cevIoeq|MM?p#9(axBN}jC;QB;sd5Jpa0}s*-Hr+*O|R(=CM-;jkeCC
z<YkWt*Xvbjm$j@TJ};tt<Wc$no~G7GV+OO#Gml|hj6}%&^;Oe)ry>Xg+r|^4&w|fp
zNVN@@hgj`jtc&M8HmXn0Ms6gsv2&t!J^NdaLdX}Mq@;R0c+ma&Du|=WSs4oY;Ha2k
za{u8Br|Zb4_(X=voQvJLk92Wxz^9Q6MM4q%WC@^<g`b+&Lf=tx-!j*0Pr)Qt2hna-
zv@JIByk7NxPPWm}-Rz733gd9z3d4TxkVw&ZzO}_q1J<%<PNEk}d3WccfE`*@go>W0
zWnkZkq0J4$d?c3XlXgP$J{K;SKl97gDsF!TZcMgl2vya-3pMhtWc`iX>@s+{ofYgm
zZeHNG<H*zK!8}>(-(u>N&t6r@_E?h_F+&;Y9ZAcy#RbNcLyZfhS37#|0&{_qumM}H
z+inWV`$EqpQ^{S|MHR_@x-@pRm4)&6E!;Ly2w|J3#4cUVt}HCYL(sEO%F=9_^^7#2
zGqZha!f0pDU6H!79Y?7NGHBWz@2l}ZRy@eh;1T>t^)^HH7Sbo<6MiW*0_9G`JlDb$
zIu)<9Yv`#@H_00!uT%YebiS{PMr~gQOlP)UC{X4G7Uhp;y^DNU-R>Q4@Fl`cgp!c!
z!3){2Qpkox3PYY<c^OM~WPRYQhXUhL4g7bP5~=+b=L3X4pykbbP3=IYe$Xm(dZeu!
zR}@$_n%Sf0TkxNB(KL-i>jhlC0<%aQcP(==P?DM}NwDi2-vndOW?kCFyGqJhT>U9<
zPVLuST6WqD(H*#Wa#qMRpH;6ahVJGCv4S1qIso?wT}j}4Fe4{%_whGhUoW~5D+FUM
z^UX9RQsQ6{=r;w1Y=Rk=hgIoX7AlZpOnMgGtrto8Ze6@^#&k=3oeC~~^idqAvrs~}
z_3cbe`FKn5(>?p9ql8gaE#}qPImGcYWnQQ?B-X+4@k3Z98#q4!K0MESJz%T$ZFp@5
z_^WtE_iM`VD1Gyjr0uluF1qlJs2dqwa!%?T)!k{<^O)>Hn~M{K|3Tpd&#q#L<4zEt
zZr(aO6~N6tsR)fj8~SoX8RKFTV%9vl6Gnnzc_SedPF`2VDs3X}3&&#SDJa$3roUNa
z(ZNHdN*p#JH&gUSPRf!&L(|RQOV^2M;AvR~ElzBKZ~x<$!P%G(3K5*eG0zDEm2uf5
z2sz_j2z7AXVbZfMW*>@2;TGj>ezsY$Nndq;T-r1R*2V(n&!C1-OutFq*_RBd4c1F!
z5clO9n^5rO)c|@%1lXXGOInWkEghE7j<C${z|X{y_x}(%QBzF-%$=bUcT{-pS)yZm
z$c~=PQe>SnLFd?`$|$UR`QnCd%PQJ~jrujAw(XeGzAhiGg`VY*8;M<0Tyy_C3qx8t
z2ahh&DUu#y`*Q<F6D=rQRC#)fSj%F*ExNDPO!|^!PZ^(aOo6KSA&%K{bS`g28+=Vn
zlxn_~KZ;+i@fMCad1|*YD@4cEkk8KxOmjgh9Fx=tdul#swbUpS6=Zf(w|qEPGeM6Y
z*i>P)xC`yckX{ixH*>y#>cc>hYh%NNzY@t21WPD-)1{Gv$~-_zrL#}-<$kmSg|sBp
z*Iob~%H){57Z?hd3&3?^`ON<yi3@K!fvBH~MPk&81*0Gv4V~FgR(@bQ?EQx1JkCx{
zQU&YW;%Qs~+HI*fhS<LFwJ0y;gVbZ-w$xE@U}iyo|JSeh6{z788l93?x^UV12(<dR
z09*JT?T{Kzj2(DIJ}29SQWDv~F999lg=nP1kNJU?-0Pd!D&s5=P=eHdGA-THz?3t7
z;wwe>s-S_9T83f&wSAI*)l1+yQY;pTv0o_&yOkXf-ua-f_=d{lFvfOXOsFw5zU7BY
z>{n_#ETak7wlY@~k&n&D%d)%;c|r}9tB0FO<oC-nrlFQri+Qr(y$&3w7M{psoATIn
zN;bfd9~iSjpb4s^4N!|3>5xY-lkT4OYb~`1`wfXAb;9_`%jmtZvMWl9uq}Gg8jHHI
z!vVeZe^Z`~L(0rP_3_?~;Rhuah%YikJePoZ8G|rb-rqV?fiR^c41yQDE+8;V`+g77
z@g}-Wigk590)LYNJyZu(kY9tlQ`N5KEM&Xtd$FKnAtX_5Jyo+A=CMzlZx#F)_=8tn
ze&jSGSj~u1_t6c5XUT%B(Z8#)CH?SCEtOBgATSC7Q;lN%x%)-`lQyH*)=fPGV2KT;
z-<~@XbIkeB;8c8b<?GBPeO>d(51+1l^}*>`b%=W^MM-__N6&p}PLf#`MF)+dyb@Ke
z%_3|G)u{5++j;rqWD>LRuCH~}KF{7Bjb$ct;(RD5*4}#b-hn`f#1NHg%CXg-V9AzE
znS31<QEi91f~SMtw+6sPelBPa`3T-N#T&3tnoy8sefEu-tjlbzeb=jr0;;ADVgp|&
zMlb+CiZQedyWzYEekhdNIpj!;=w|3i<z@8Yjj~N32*tr>iPlRUi}41XNP#rj`xD(P
zEI&J>9$eGO&dr6*uS<dSHR~A=Vti)qIB}-x{Jp1C<b2xXMK$JgzsRM;1uXJcgIOWc
z!OVF0Hzd;q;qUv<#*^luoqB#{!8vO|<_o_EpaX`W2dtm$KjvhH2WGJ_t-d)TuufEM
zcykfeYIG-d^}uIDmTMu<)XYcfN4=wARSv6@$ATpmt3B|qYq<)+CsmnLXdGuPM1yb>
zs#(-J;r#mt=Dj_)taDqDTqOMMJzkIc7nobjU3Zj%MB3BpC+ZKc<ehfoWf0^QjkSxd
zFC_0R6f{I0cj$+HUT(5Fbf)O^)D5>#l*?Wxd{GETv1@3`q+EW`<xthBG7O*k*U`Sa
z)Omj>)W*I(-}H|}W&Pe_TAhRUOb6Mh)bN4~$4&C6Qf7~NQ%{_dcbkzle&ju?BCZDD
ziUAW-AO`qP-ZW=plLe_cQzy!ohwGz?Qyy#$b_L2PT}y3GO>{zzbRjde^GCE~lDdG2
zz^SAD{*-TFf|9U@w#gn%pJ(wixjylzbIr|!<9a==<87D1gkp9ww0&z|GR>5~AOpq*
zb<8o==773zHyY|hiQc8Wn#WzvbINS6|J9n~wPHx;Fq?bCf|}mt#I@EPDk;nz2vByN
zB;?j|AdJe)%~Pi5WWN|BU2wOa&fvilf_p-2mQJF~WmCUsieCl`3U*2U%Ds*6J6|>?
zU2%f~oGT9o%YNlFQZU*uz;$ohxxFm&_?~oSRoWw9+{tVm*)2`f^9U&2teWJJ58{3^
z$qoi`)+N5UniY$v&Kz1&&q&hh6KH}Q{Ew*O5E<uYUJ59su>kdk<*3FXJ!QWYo4a8g
z9qeFq3Ew$K@YVq~zHKjPwrP(ps?jQldb6KHG_068rlsQb$LAvj8#KXju`I{J8YAb)
ztPJg8yuqxfGui_Zg;dW_!R2a8WY30^5w3%&Ek&3!wo?~N0?Tnm#0n&IPR`ZeSO|V&
zyuv4A$-YMGJlXg*gorCAk|R&~7W1dYE^T|RCI%n$<#hkCDbrSbO1RXvQm3^;@dkGp
zSI#`MUUgSKn^jIEd%QjgawBD(eJhPq#0v?TDEU0|rVHep!d$f-8J<(_fsY!Wx5OKN
zD1_?Ui~c3@CqHDVBghx+#H8NVS&lGxtR&6fh4)*UJ7thp(yVd=1B$5g@#+iRa>2g_
zhI9iLyZOJ(M~X6(+}vaTPOsz7m#MtmQ^6~9&LOplqXQg#D_MaeoCen}etOF{?^A%$
zaR3iL&<_P9{$E+QN!GEmBbM`#X}@<%$HvAcLIkx(wxbvvs00Q4>_*M6@WZ;lhi*C_
z1WJ3rGhN#pWJDsZ2=#tttv^E5e7P#CjJj$fSuVYo`P&3N;mUM%NX#Ztz)Z>pQUd8i
zbI_k!v-ZEa4K@aK^2oR2r)bFB>}9RAudT>`hH+XEl0@IYT24cW<#?=otXf#pwmw_!
z;55l6^GEgUA4W|vzrWqwP1}tKJPGFCN8~mN89$2LIZI|5DfiE5ed49?(EC1+C*J4s
zCG}{zq4(WM86!O%i`=mHDZSqr2;U{LCfsz%WAJLsx;Jq13hvC2{loEz<P}!;miK79
z9X*lh$p0K4)-t**F%t4+iBRL7!z-i9O(mPrn+UWm|CC!MTMO{*0<nV^X*xyL_(3C!
z*TyC&t!o3ue5#beTwNrJn8@PU-f4wj@@M)T;*x~z+wyIyGtpbv-kp{uP~V>n8qzXA
zsP~@dg8R&#_%9IMd!Z|jt2fhlu`&mlkE`*O0*nf;WCe#=?q@HfrP2@+KjTfonzE`M
zII)k5u0x&6o5d-iNai%JK($kPGvR|f{J;~}e1B*&0}uux@(Z8$W?idezhz<<l3rjj
z*38T@a2nW<>}By{_U~5{N?WBOfD~#UBeG(r(P{(3De(xNo2{p%Q=1`<)=s(V4M(_2
z!M|U+3LBg8a+Q1N(9)<xlVuxfe1x^g`8R28(N-4~IU@tzlk<nI!pO{wC{1v8b+f^z
zL;Gccbceeisx#>-Q})iRJn#IBDR+ftV7ICYGOKYHr4rWC))3nSR;rCDbvM%fONh-;
zLv;j~Z^%)yPd>)b<jKd?;uyefwNO-RvRTe^jOFmu>fp1*XC4z(nf<D92UdiP8iM`Q
zRDQV^+|k0aV%kR`49hv)oFW_Kw7j$ct<YI(3Ng0RooZ;tr-H#{W<gac2ZOm}!s&8z
zP{4JVrONCo;46Lw_cWDiC=S*7x2?bc&wfCe5wYw=qek{b9$6S__G8f|v6=B84%q6@
zW4;|3#2ez5erKDP<;{DO?SLnx=_cEc*1jAjh}-<Id`Q0`A6SigSFyFpHA*kTK&+lw
zjP_CH@6Qx!OkbG({NZgWWBg!RhS5cGluaB35xW>{`UiCxUz$9{zFUO=%3%}9J_XY`
z-;RB@1FLss?p5JHAP@CR=vS_ayy(q}KGao_);cFq#wGb1{}#p-U7YQjv-{`!WASeL
owos4?@IT-5)Aom#U>GnmnGnRfew+E<BLmRB|L9(onr-O+0kuvLg#Z8m


From 140f6f87d0195ef19d592fe21e9b9c16d8820551 Mon Sep 17 00:00:00 2001
From: Jan D''Orgeville <jdorgeville@spiria.com>
Date: Wed, 6 Jun 2018 08:25:18 -0400
Subject: [PATCH 2/4] fixes, and make it more robust after various tests

---
 .../ProductsManager.cs                        |  9 +++++++
 .../Tools/Presistence.cs                      | 10 +++++++-
 .../VersionSelectorApp.cs                     |  5 +++-
 .../VersionSelectorButton.cs                  | 24 +++++++++++--------
 4 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
index b74d6b3c22..fed6a22f48 100644
--- a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
@@ -115,6 +115,15 @@ protected IEnumerable<Product> FindDynamoRevitInstallations(string debugPath)
                 );
         }
 
+        /// <summary>
+        /// Return true if Product list contains a specific version
+        /// </summary>
+        public bool Contains(Version version)
+        {
+            if (version == Product.LASTESTDYNAMO) return mProducts.Count > 0;
+            return mProducts.ContainsKey(version);
+        }
+
         /// <summary>
         /// Check if a specific Product is currently loaded
         /// </summary>
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
index c209039504..c1c2eac54f 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
@@ -50,7 +50,15 @@ public static Version ActiveVersion {
                 Object obj = null;
                 GetValue(RegKey, VERSION, ref obj);
                 if (obj == null) return null;
-                if (obj.GetType() == typeof(String)) return new Version((string)obj);
+                if (obj.GetType() == typeof(String))
+                {
+                    try {
+                        return new Version((string)obj);
+                    } catch (Exception e) {
+                        Debug.Write(e);
+                        return null;
+                    }
+                }
                 return null;
             }
 
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
index 9e06a653a2..dab50acff6 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
@@ -45,6 +45,8 @@ public Result OnStartup(UIControlledApplication application)
             try
             {
                 activeVersion = Tools.Presistence.ActiveVersion;
+                if (!DynamoProducts.Contains(activeVersion)) activeVersion = Product.LASTESTDYNAMO;
+                Tools.Presistence.ActiveVersion = activeVersion;
             }
             catch (Exception) { /* */ }
 
@@ -55,10 +57,11 @@ private Result LoadDynamoProduct(Version version) {
             // Start Dynamo Product
             try
             {
-                DynamoProducts.Load(Tools.Presistence.ActiveVersion);
+                DynamoProducts.Load(version);
                 return Result.Succeeded;
             }
             catch (Exception) { /* */ }
+
             return Result.Failed;
         }
 
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
index 8b3831d1a4..24f0724e09 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
@@ -38,11 +38,16 @@ public void AddInRibbon()
 
         private void OnClick()
         {
-            // retreived current active version
+            // Latest version available
             Version latestVersion = mProductList.First().Version;
-            Version currentVersion = Tools.Presistence.ActiveVersion;
-            if (currentVersion == Product.LASTESTDYNAMO)
-                currentVersion = latestVersion;
+
+            // Current Version loaded in appDomain
+            Version currentVersion = latestVersion;
+            var isCurrentVersion = ProductsManager.IsProductLoaded(ref currentVersion);
+
+            // Selected Version
+            Version selectedVersion = Tools.Presistence.ActiveVersion;
+            if (selectedVersion == Product.LASTESTDYNAMO) selectedVersion = latestVersion;
 
             // Creates a Revit task dialog to communicate information to the user.
             TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
@@ -57,7 +62,7 @@ private void OnClick()
             {
                 item.isCurrent = (item.Version == currentVersion);
                 mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, item.Title, item.SubTitle);
-                if (item.isCurrent) defaultResult = (TaskDialogResult)id;
+                if (item.Version == selectedVersion) defaultResult = (TaskDialogResult)id;
                 id++;
             }
             mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
@@ -70,13 +75,12 @@ private void OnClick()
             var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
             try
             {
-                var selectedVersion = mProductList[index].Version;
-                if (selectedVersion == latestVersion)
-                    selectedVersion = Product.LASTESTDYNAMO;
+                var version = mProductList[index].Version;
+                if (version == latestVersion) version = Product.LASTESTDYNAMO;
 
                 // Save Result
-                Tools.Presistence.ActiveVersion = selectedVersion;
-                OnVersionSelected(selectedVersion);
+                Tools.Presistence.ActiveVersion = version;
+                OnVersionSelected(version);
             }
             catch (Exception) { /* */ }
 

From 1f77272aeb84ebb6780f56885a4a41865be43595 Mon Sep 17 00:00:00 2001
From: Jan D''Orgeville <jdorgeville@spiria.com>
Date: Tue, 12 Jun 2018 11:46:44 -0400
Subject: [PATCH 3/4] Bring back old selector behavior (to change Version on
 each Revit Session)

---
 .../CommandsBinders.cs                        | 131 +++++++++++++
 .../DynamoRevitVersionSelector.csproj         |   2 +
 .../DynamoRevitVersionSelector/Product.cs     |  66 ++++++-
 .../ProductsManager.cs                        | 175 +++++++++++++-----
 .../Properties/Resources.Designer.cs          |  18 ++
 .../Properties/Resources.en-US.resx           |   6 +
 .../Properties/Resources.resx                 |   6 +
 .../DynamoRevitVersionSelector/Tools/UI.cs    |  54 +++++-
 .../VersionDialog.cs                          |  84 +++++++++
 .../VersionSelectorApp.cs                     | 156 ++++++++++++----
 .../VersionSelectorButton.cs                  |  66 +------
 11 files changed, 615 insertions(+), 149 deletions(-)
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs
 create mode 100644 src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs

diff --git a/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs b/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs
new file mode 100644
index 0000000000..bb7da0ffe2
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+using Autodesk.Revit.UI.Events;
+
+namespace Dynamo.Applications
+{
+    /// <summary>
+    /// Bind/Unbind Ribbons Icon actions
+    /// </summary>
+    internal class CommandsBinders
+    {
+        #region Statics
+        /// <summary>
+        /// Dynamo Command ID
+        /// </summary>
+        public static readonly string DYNAMOID = "ID_VISUAL_PROGRAMMING_DYNAMO";
+
+        /// <summary>
+        /// Dynamo Player Command ID
+        /// </summary>
+        public static readonly string PLAYERID = "ID_PLAYLIST_DYNAMO";
+        #endregion
+
+        public event EventHandler<ExecutedEventArgs> OnDynamoClick;
+        public event EventHandler<ExecutedEventArgs> OnDynamoPlayerClick;
+
+        private UIControlledApplication uiControlledApplication;
+        private RevitCommandId DynamoCmdId;
+        private AddInCommandBinding DynamoCommand = null;
+        private RevitCommandId DynamoPlayerCmdId;
+        private AddInCommandBinding DynamoPlayerCommand = null;
+
+        private bool BindDynamoPlayer;
+
+        /// <summary>
+        /// Is Binding has been done
+        /// </summary>
+        public bool IsBinded { get; private set; }
+
+        /// <summary>
+        /// Constructor, Class to Bind/Unbind Ribbons Icon actions
+        /// </summary>
+        /// <param name="application"></param>
+        /// <param name="bindDynamoPlayer"></param>
+        public CommandsBinders(UIControlledApplication application, bool bindDynamoPlayer)
+        {
+            uiControlledApplication = application;
+            BindDynamoPlayer = bindDynamoPlayer;
+            DynamoCmdId = RevitCommandId.LookupCommandId(DYNAMOID);
+            DynamoPlayerCmdId = RevitCommandId.LookupCommandId(PLAYERID);
+            if (uiControlledApplication == null || DynamoCmdId == null || DynamoPlayerCmdId == null)
+                throw new ArgumentNullException();
+            IsBinded = false;
+        }
+
+        /// <summary>
+        /// Bind Ribbons Icon actions
+        /// </summary>
+        public void Bind()
+        {
+            if (IsBinded) return;
+            if (null == DynamoCommand)
+            {
+                DynamoCommand = uiControlledApplication.CreateAddInCommandBinding(DynamoCmdId);
+                DynamoCommand.CanExecute += canExecute;
+                DynamoCommand.BeforeExecuted += beforeExecuted;
+                DynamoCommand.Executed += executedDynamo;
+            }
+            if (null == DynamoPlayerCommand && BindDynamoPlayer)
+            {
+                DynamoPlayerCommand = uiControlledApplication.CreateAddInCommandBinding(DynamoPlayerCmdId);
+                DynamoPlayerCommand.CanExecute += canExecute;
+                DynamoPlayerCommand.BeforeExecuted += beforeExecuted;
+                DynamoPlayerCommand.Executed += executedPlayer;
+            }
+            IsBinded = true;
+        }
+
+        /// <summary>
+        /// UnBind Ribbons Icon actions
+        /// </summary>
+        public void UnBind()
+        {
+            if (!IsBinded) return;
+            if (null != DynamoCommand)
+            {
+                uiControlledApplication.RemoveAddInCommandBinding(DynamoCmdId);
+                DynamoCommand.BeforeExecuted -= beforeExecuted;
+                DynamoCommand.CanExecute -= canExecute;
+                DynamoCommand.Executed -= executedDynamo;
+                DynamoCommand = null;
+            }
+            if (null != DynamoPlayerCommand)
+            {
+                uiControlledApplication.RemoveAddInCommandBinding(DynamoPlayerCmdId);
+                DynamoPlayerCommand.BeforeExecuted -= beforeExecuted;
+                DynamoPlayerCommand.CanExecute -= canExecute;
+                DynamoPlayerCommand.Executed -= executedPlayer;
+                DynamoPlayerCommand = null;
+            }
+            IsBinded = false;
+        }
+
+        private void beforeExecuted(object sender, BeforeExecutedEventArgs e)
+        {
+            e.UsingCommandData = true;
+        }
+
+        private void canExecute(object sender, CanExecuteEventArgs e)
+        {
+            e.CanExecute = e.ActiveDocument != null;
+        }
+
+        private void executedDynamo(object sender, ExecutedEventArgs e)
+        {
+            OnDynamoClick(sender, e);
+        }
+
+        private void executedPlayer(object sender, ExecutedEventArgs e)
+        {
+            OnDynamoPlayerClick(sender, e);
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
index 1864333e7c..ea6f1f366d 100644
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
+++ b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
@@ -58,6 +58,7 @@
     <Compile Include="$(SolutionDir)AssemblySharedInfoGenerator\AssemblySharedInfo.cs">
       <Link>Properties\AssemblySharedInfo.cs</Link>
     </Compile>
+    <Compile Include="CommandsBinders.cs" />
     <Compile Include="Product.cs" />
     <Compile Include="ProductsManager.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
@@ -73,6 +74,7 @@
     <Compile Include="Tools\ImageConversion.cs" />
     <Compile Include="Tools\Presistence.cs" />
     <Compile Include="Tools\UI.cs" />
+    <Compile Include="VersionDialog.cs" />
     <Compile Include="VersionSelectorApp.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="VersionSelectorButton.cs" />
diff --git a/src/Legacy/DynamoRevitVersionSelector/Product.cs b/src/Legacy/DynamoRevitVersionSelector/Product.cs
index afb2dddfc3..79dad6369f 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Product.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Product.cs
@@ -17,11 +17,18 @@ internal class Product
     {
         #region Statics
         /// <summary>
-        /// A way to says "plz keep using the lastest installed version available".
-        /// This should be the default value / lazy case (think if the end-user never use this DynamoRevitSelector facility).
-        /// We assume, that if the end-user selects explicitly the lastest version, then he'll keep follow tatest version
+        /// A way to says "do not loat load Dyanmo during starup".
         /// </summary>
-        public static readonly Version LASTESTDYNAMO = null;
+        /// <remarks>
+        /// Legacy use case - This should be the default case
+        /// This might be usefull when people need to change Dyanmo version on each Revit Session
+        /// </remarks>
+        public static readonly Version NODYNAMO = null;
+
+        /// <summary>
+        /// A way to says "please keep using the lastest installed version available".
+        /// </summary>
+        public static readonly Version LASTESTDYNAMO = new Version(0,0,0,0);
 
         /// <summary>
         /// Dynamo product's assembly should always define the same type name
@@ -61,22 +68,41 @@ public string Title
         {
             get
             {
+                if (Version == NODYNAMO)
+                    return Resources.DynamoVersionKeepClear;
                 var msg = isCurrent ? Resources.DynamoCurrentVersionText : Resources.DynamoVersionText;
                 return string.Format(msg, Version.ToString(4));
             }
         }
 
         /// <summary>
-        /// How to describe this product in (Sub Title)
+        /// How to describe this product (Sub Title)
         /// </summary>
         public string SubTitle
         {
             get; set;
         }
+
+        /// <summary>
+        /// Generic String conversion
+        /// </summary>
+        public override string ToString()
+        {
+            return Title;
+        }
+
+        /// <summary>
+        /// Get product instance (if it has been created)
+        /// </summary>
+        /// <seealso cref="CreateInstance"/>
+        public Object Instance
+        {
+            get; private set;
+        }
         #endregion
 
         /// <summary>
-        /// Generic contructor
+        /// Lazy constructor
         /// </summary>
         public Product(Version version)
         {
@@ -84,7 +110,7 @@ public Product(Version version)
         }
 
         /// <summary>
-        /// Contructor, for a full defined product
+        /// Constructor, for a full defined/existing dynamo product
         /// </summary>
         public Product(Version version, string assemblyPath, string installFolder)
         {
@@ -111,13 +137,37 @@ public Object CreateInstance()
             }
             try
             {
-                return asm.CreateInstance(DYNAMO_TYPENAME);
+                Instance = asm.CreateInstance(DYNAMO_TYPENAME);
+                return Instance;
             }
             catch (Exception)
             {
                 throw new System.MethodAccessException($"AsssemblyPath '{AsssemblyPath}', can't be access to '{DYNAMO_TYPENAME}'");
             }
         }
+
+        /// <summary>
+        /// Execute OnStartup() by reflection
+        /// </summary>
+        /// <param name="application"></param>
+        /// <returns></returns>
+        public Result OnStartup(UIControlledApplication application)
+        {
+            var method = Instance.GetType().GetMethod("OnStartup");
+            return (Result)method.Invoke(Instance, new object[] { application });
+        }
+
+        /// <summary>
+        /// Execute ExecuteDynamoCommand() by reflection
+        /// </summary>
+        /// <param name="journalData"></param>
+        /// <param name="appUI"></param>
+        /// <returns></returns>
+        public Result ExecuteDynamoCommand(IDictionary<string, string> journalData, UIApplication appUI)
+        {
+            var method = Instance.GetType().GetMethod("ExecuteDynamoCommand");
+            return (Result)method.Invoke(Instance, new object[] { journalData, appUI });
+        }
     }
 
 }
diff --git a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
index fed6a22f48..d2734dce0b 100644
--- a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using Autodesk.Revit.UI;
 using System.Linq;
-using DynamoRevitVersionSelector.Properties;
 using System.IO;
 using System.Reflection;
 using System.Collections;
@@ -12,68 +11,103 @@ namespace Dynamo.Applications
 {
     internal class ProductsManager
     {
-
-        #region Statics
         /// <summary>
-        /// Check if a Product is currently loaded in Current Application Domain
+        /// Check if a Product is currently loaded in Current Application Domain and returns its version.
         /// </summary>
-        /// <param name="version">If a product is loaded, provides its version.</param>
-        /// <returns>True if a Dynamo product is currently loaded</returns>
-        public static bool IsProductLoaded(ref Version version)
+        /// <returns>Dynamo product which is currently loaded, Product.NODYNAMO otherwise</returns>
+        public static Version LoadedProduct()
         {
             Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();
             foreach (Assembly asm in asms)
             {
                 if (asm.GetType(Product.DYNAMO_TYPENAME) != null)
                 {
-                    version = asm.GetName().Version;
-                    return true;
+                    return asm.GetName().Version;
                 }
             }
-            return false;
+            return Product.NODYNAMO;
+        }
+
+        /// <summary>
+        /// Revit Version
+        /// </summary>
+        public string RevitVersion
+        {
+            get; private set;
         }
-        #endregion
 
-        #region Accessors
+        #region Product List
         /// <summary>
-        /// Accessor to the list of Dyanmo Product, the list is sorted in a way that .first() is
-        /// the most recent one
+        /// Accessor to the list of Dyanmo Product (the list is sorted).
         /// </summary>
+        /// <seealso cref="Contains"/>
         public List<Product> List
         {
             get {
                 var list = mProducts.Values.ToList();
-                return list.OrderByDescending(x => x.Version).ToList();
+                return list.OrderByDescending(x => x.Version).ToList(); // -- list.first() = most recent version
             }
         }
 
         /// <summary>
         /// Number of Dyanmo Products available
         /// </summary>
+        /// <seealso cref="Contains"/>
         public int Count
         {
             get { return mProducts.Count; }
         }
 
         /// <summary>
-        /// Revit Version
+        /// Return true if Product list contains a specific version (product should exist and be a real)
         /// </summary>
-        public string RevitVersion {
-            get; private set;
+        public bool Contains(Version version)
+        {
+            if (version == Product.LASTESTDYNAMO) return false;
+            if (version == Product.NODYNAMO) return false;
+            return mProducts.ContainsKey(version);
+        }
+
+        /// <summary>
+        /// Return true if Product list contains at least one product with dynamo player in it
+        /// </summary>
+        public bool ContainsDynamoPlayer()
+        {
+            //Minimum version requirements needed by Playlist feature for Dynamo and Revit.
+            Version MinDynamoVersionForPlaylist = new Version(1, 2);
+            foreach (var p in mProducts.Values)
+            {
+                if (p.Version >= MinDynamoVersionForPlaylist)
+                    return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns one Product
+        /// </summary>
+        /// <param name="version"></param>
+        /// <returns></returns>
+        public Product Get(Version version)
+        {
+            return mProducts[version];
         }
         #endregion
 
         protected UIControlledApplication uiControlledApplication;
         protected Dictionary<Version, Product> mProducts;
 
+        public delegate void BeforeLoadEventHandler();
+        public event BeforeLoadEventHandler OnBeforeLoad;
+
         /// <summary>
-        /// Contructor
+        /// ProductsManager Contructor, Manage available Dyanmo Products (DLLs assemblies)
         /// </summary>
         public ProductsManager(UIControlledApplication application)
         {
             uiControlledApplication = application;
             RevitVersion = application.ControlledApplication.VersionNumber;
-            var revitFolder = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
+            var revitFolder = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
             var debugPath = revitFolder.Parent.FullName;
             var dynamoProducts = FindDynamoRevitInstallations(debugPath);
             mProducts = new Dictionary<Version, Product>();
@@ -94,9 +128,7 @@ protected IEnumerable<Product> FindDynamoRevitInstallations(string debugPath)
             var type = assembly.GetType("DynamoInstallDetective.Utilities");
             var LocateDynamoInstallations = type.GetMethod("LocateDynamoInstallations", BindingFlags.Public | BindingFlags.Static);
             if (LocateDynamoInstallations == null)
-            {
                 throw new MissingMethodException("Method 'DynamoInstallDetective.Utilities.LocateDynamoInstallations' not found");
-            }
 
             // Where search for "DynamoRevitDS.dll" products which follow this Pattern:
             Func<string, string> fileLocator = p => Path.Combine(p, string.Format("Revit_{0}", RevitVersion), "DynamoRevitDS.dll");
@@ -115,45 +147,92 @@ protected IEnumerable<Product> FindDynamoRevitInstallations(string debugPath)
                 );
         }
 
-        /// <summary>
-        /// Return true if Product list contains a specific version
-        /// </summary>
-        public bool Contains(Version version)
+        internal class LoadResult
         {
-            if (version == Product.LASTESTDYNAMO) return mProducts.Count > 0;
-            return mProducts.ContainsKey(version);
+            /// <summary>
+            /// Version before Load() call
+            /// </summary>
+            public Version fromVersion;
+
+            /// <summary>
+            /// Version after Load() call
+            /// </summary>
+            public Version afterVersion;
+
+            public enum ResultType {
+                FAILED,
+                DONE,
+                PENDING
+            };
+
+            /// <summary>
+            /// Load Result
+            /// </summary>
+            public ResultType Result;
+
+            public bool IsSucceed {
+                get { return Result != ResultType.FAILED; }
+            }
         }
 
         /// <summary>
-        /// Check if a specific Product is currently loaded
+        /// Load a specific product version
         /// </summary>
-        public void Load(Version version)
+        /// <param name="version">Version expected</param>
+        /// <returns>Succeed if no error occurs</returns>
+        public LoadResult Load(Version version)
         {
             // Retreived product
-            var product = (version == Product.LASTESTDYNAMO) ? this.List.First() : mProducts[version];
-
-            // Is a dynamo product already loaded ?
-            Version currVersion = Product.LASTESTDYNAMO;
-            if (IsProductLoaded(ref currVersion))
+            Product product = null;
+            do
             {
-                var popup = new TaskDialog(Resources.DynamoVersions);
-                popup.MainInstruction = Resources.DynamoVersionSelection;
-                if (product.Version == currVersion)
+                if (version == Product.NODYNAMO)
                 {
-                    popup.MainContent = String.Format(Resources.ProductLoaded, product.Version);
+                    product = new Product(Product.NODYNAMO);
+                    break;
                 }
-                else
+                if (version == Product.LASTESTDYNAMO)
                 {
-                    popup.MainContent = String.Format(Resources.ProductNeedToRestartRevit, product.Version);
+                    product = this.List.First();
+                    break;
                 }
-                popup.Show();
-                return;
+
+                product = mProducts[version];
+            } while (false);
+
+            LoadResult ret = new LoadResult();
+            ret.fromVersion = LoadedProduct();
+            ret.afterVersion = product.Version;
+
+            // Trivial - nothing to do
+            if (ret.fromVersion == ret.afterVersion)
+            {
+                ret.Result = LoadResult.ResultType.DONE;
+                return ret;
+            }
+
+            // Can we Load dll right now ?
+            if (ret.fromVersion != Product.NODYNAMO)
+            {
+                ret.Result = LoadResult.ResultType.PENDING;
+                return ret;
+            }
+
+            // Actual Load
+            try
+            {
+                OnBeforeLoad?.Invoke();
+                product.CreateInstance();
+                if (Result.Succeeded != product.OnStartup(uiControlledApplication))
+                    throw new Exception("OnStartup() Error");
+                ret.Result = LoadResult.ResultType.DONE;
+                return ret;
+            }
+            catch
+            {
+                ret.Result = LoadResult.ResultType.FAILED;
+                return ret;
             }
-            
-            // Start Dyanmo product
-            var inst = product.CreateInstance();
-            var OnStartup = inst.GetType().GetMethod("OnStartup");
-            OnStartup.Invoke(inst, new object[] { uiControlledApplication });
         }
     }
 }
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
index 081e98f2f5..884cbfedf2 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
@@ -79,6 +79,15 @@ internal static string DynamoCurrentVersionText {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to None.
+        /// </summary>
+        internal static string DynamoVersionKeepClear {
+            get {
+                return ResourceManager.GetString("DynamoVersionKeepClear", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Dynamo Version.
         /// </summary>
@@ -106,6 +115,15 @@ internal static string DynamoVersionText {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to You need to restart Revit to apply this change.
+        /// </summary>
+        internal static string NeedToRestartRevit {
+            get {
+                return ResourceManager.GetString("NeedToRestartRevit", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Dynamo [{0}] is selected..
         /// </summary>
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
index 905541f0ff..a8a4edd8fe 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
@@ -152,4 +152,10 @@ Please restart Revit to use it.</value>
   <data name="DynamoCurrentVersionText" xml:space="preserve">
     <value>Dynamo {0} (current)</value>
   </data>
+  <data name="DynamoVersionKeepClear" xml:space="preserve">
+    <value>None</value>
+  </data>
+  <data name="NeedToRestartRevit" xml:space="preserve">
+    <value>You need to restart Revit to apply this change</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
index 905541f0ff..a8a4edd8fe 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
@@ -152,4 +152,10 @@ Please restart Revit to use it.</value>
   <data name="DynamoCurrentVersionText" xml:space="preserve">
     <value>Dynamo {0} (current)</value>
   </data>
+  <data name="DynamoVersionKeepClear" xml:space="preserve">
+    <value>None</value>
+  </data>
+  <data name="NeedToRestartRevit" xml:space="preserve">
+    <value>You need to restart Revit to apply this change</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
index cc1485a827..344056f7f0 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
@@ -1,4 +1,5 @@
-using System;
+using Autodesk.Revit.UI;
+using System;
 using System.Collections.Generic;
 using adWin = Autodesk.Windows;
 
@@ -13,12 +14,18 @@ static UI() {
         // UI Event Handling
         private delegate void EventHandler(object sender, adWin.UIElementActivatedEventArgs e);
         private static Dictionary<string, EventHandler> listener = new Dictionary<string, EventHandler>();
+        private static readonly OperationRequestHandler opReq = new OperationRequestHandler();
         private static void OnUIEvent(object sender, adWin.UIElementActivatedEventArgs e)
         {
             if (e == null) return;
             if (e.Item == null) return;
             if (e.Item.Id == null) return;
-            if (listener.ContainsKey(e.Item.Id)) listener[e.Item.Id](sender, e);
+            if (listener.ContainsKey(e.Item.Id))
+            {
+                opReq.Raise(() => {
+                    listener[e.Item.Id](sender, e);
+                });
+            }
         }
 
         ///
@@ -143,5 +150,48 @@ public PushButtonData(string Id, string name = "", string text = "")
                 listener.Add(btn.Id, this.OnUIEvent);
             }
         }
+
+        private class OperationRequestHandler : IExternalEventHandler
+        {
+            public delegate void Operation();
+            private Operation mOperation = null;
+            private readonly Object opLock = new Object();
+            ExternalEvent m_exEvent = null;
+
+            public OperationRequestHandler()
+            {
+                m_exEvent = ExternalEvent.Create(this);
+            }
+
+            public void Raise(Operation operation)
+            {
+                lock (opLock) mOperation = operation;
+                m_exEvent.Raise();
+            }
+
+
+            public String GetName()
+            {
+                return "UI OperationRequestHandler";
+            }
+
+            /// <summary>
+            ///   The top method of the event handler.
+            /// </summary>
+            /// <remarks>
+            ///   This is called by Revit after the corresponding
+            ///   external event was raised (by the modeless form)
+            ///   and Revit reached the time at which it could call
+            ///   the event's handler (i.e. this object)
+            /// </remarks>
+            /// 
+            public void Execute(UIApplication uiapp)
+            {
+                lock (opLock)
+                {
+                    mOperation();
+                }
+            }
+        }
     }
 }
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs b/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs
new file mode 100644
index 0000000000..20440a49cb
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+
+namespace Dynamo.Applications
+{
+    internal class VersionDialog
+    {
+        public delegate void SelectedEventHandler(Version version);
+        public event SelectedEventHandler OnSelection;
+
+        private List<Product> mProductList;
+
+        /// <summary>
+        /// Dialog to provide a Dyanmo Version Picker
+        /// </summary>
+        /// <param name="ProductList">List of product to show up</param>
+        public VersionDialog(List<Product> ProductList)
+        {
+            mProductList = ProductList;
+        }
+
+        /// <summary>
+        /// Add the option to select "No Dynamo"
+        /// </summary>
+        public void AddNoDynamoOption()
+        {
+            mProductList.Add(new Product(Product.NODYNAMO));
+        }
+
+        /// <summary>
+        /// Show modal dialog
+        /// </summary>
+        public void Show()
+        {
+            // Latest version available
+            Version latestVersion = mProductList.First().Version;
+
+            // Current Version loaded in appDomain
+            Version currentVersion = ProductsManager.LoadedProduct();
+             
+            // Selected Version
+            Version selectedVersion = Tools.Presistence.ActiveVersion;
+            if (selectedVersion == Product.LASTESTDYNAMO) selectedVersion = latestVersion;
+
+            // Creates a Revit task dialog to communicate information to the user.
+            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
+            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
+            mainDialog.MainContent = Resources.VersionSelectionContent;
+
+            // Add commmandLink options to task dialog
+            int id = (int)TaskDialogCommandLinkId.CommandLink1;
+            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
+            foreach (var item in mProductList)
+            {
+                item.isCurrent = (item.Version == currentVersion);
+                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, item.Title, item.SubTitle);
+                if (item.Version == selectedVersion) defaultResult = (TaskDialogResult)id;
+                id++;
+            }
+            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
+            mainDialog.DefaultButton = defaultResult;
+
+            TaskDialogResult tResult = mainDialog.Show();
+            if (tResult == TaskDialogResult.Close)
+                return;
+
+            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
+            try
+            {
+                var version = mProductList[index].Version;
+
+                // overwrite version by LASTESTDYNAMO, to keep tracking the latest version
+                if (version == latestVersion) version = Product.LASTESTDYNAMO;
+
+                // Propagate Version selection
+                OnSelection(version);
+            }
+            catch (Exception) { /* */ }
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
index dab50acff6..a810d2bcb0 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
@@ -1,19 +1,11 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Drawing;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Windows;
-using System.Windows.Interop;
-using System.Windows.Media.Imaging;
 using Autodesk.Revit.Attributes;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.UI;
+using Dynamo.Applications;
 using Autodesk.Revit.UI.Events;
+using System.Diagnostics;
 using DynamoRevitVersionSelector.Properties;
-using Microsoft.Win32;
 
 namespace Dynamo.Applications
 {
@@ -23,46 +15,146 @@ public class VersionLoader : IExternalApplication
     {
         ProductsManager DynamoProducts;
 
+        /// <summary>
+        /// VersionSelector starting point
+        /// </summary>
+        /// <param name="application"></param>
+        /// <returns></returns>
         public Result OnStartup(UIControlledApplication application)
         {
-            // Find available Dyanmo Products
+            // Find available Dynamo Products
             DynamoProducts = new ProductsManager(application);
             if (DynamoProducts.Count == 0)
-            {
                 return Result.Failed;
-            }
 
-            // If multiple product are available then add a selection Button in the Ribbon
+            // May be needed to re-route Revit Icons commands, if no Revit product is loaded
+            var Commands = new CommandsBinders(application, DynamoProducts.ContainsDynamoPlayer());
+            Commands.OnDynamoClick += OnDynamoIconClick;
+            Commands.OnDynamoPlayerClick += OnDynamoPlayerIconClick;
+            DynamoProducts.OnBeforeLoad += new ProductsManager.BeforeLoadEventHandler(delegate () {
+                Commands.UnBind();
+            });
+
+            // If multiple product are available then add a Version Selection Button in the Ribbon
             if (DynamoProducts.Count > 1)
             {
-                var selectBtn = new VersionSelectorButton(application, DynamoProducts.List);
+                var selectBtn = new VersionSelectorButton();
                 selectBtn.AddInRibbon();
-                selectBtn.OnVersionSelected += LoadDynamoProduct;
+                selectBtn.OnButtonClick += OnDynamoVersionIconClick;
             }
 
-            // Get Persisted Dyanmo Version (by default get latest)
-            Version activeVersion = Product.LASTESTDYNAMO;
-            try
+            // Get Persisted Dynamo Version
+            Version activeVersion;
+            activeVersion = Tools.Presistence.ActiveVersion;
+            if ((activeVersion != Product.LASTESTDYNAMO) && (!DynamoProducts.Contains(activeVersion)))
+                activeVersion = Product.NODYNAMO; // default
+            
+            // Write it back to keep consistency
+            Tools.Presistence.ActiveVersion = activeVersion;
+
+
+            if (activeVersion == Product.NODYNAMO)
             {
-                activeVersion = Tools.Presistence.ActiveVersion;
-                if (!DynamoProducts.Contains(activeVersion)) activeVersion = Product.LASTESTDYNAMO;
-                Tools.Presistence.ActiveVersion = activeVersion;
+                Commands.Bind();
             }
-            catch (Exception) { /* */ }
+            else
+            {
+                // load expected product
+                var ret = DynamoProducts.Load(activeVersion);
+                if (!ret.IsSucceed) {
+                    /* Error, go back in a safe position for the next time */
+                    Tools.Presistence.ActiveVersion = Product.NODYNAMO;
+                    return Result.Failed;
+                }
+            }
+
+            return Result.Succeeded;
+        }
+
+        /// <summary>
+        /// Event when user click on "Dynamo" Icon
+        /// </summary>
+        /// <remarks>Only occurs if icon associated commands has been binded</remarks>
+        private void OnDynamoIconClick(object sender, ExecutedEventArgs e)
+        {
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 1- Load Dynamo */
+                DynamoProducts.Load(v);
+            });
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 2- Start Dynamo */
+                Version currentversion = ProductsManager.LoadedProduct();
+                if (currentversion == Product.NODYNAMO) throw new ArgumentException($"{v} is not loaded");
+                UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
+                DynamoProducts.Get(currentversion).ExecuteDynamoCommand(e.GetJournalData(), uiApp);
+            });
 
-            return LoadDynamoProduct(activeVersion);
+            dlg.Show();
         }
 
-        private Result LoadDynamoProduct(Version version) {
-            // Start Dynamo Product
-            try
+        /// <summary>
+        /// Event when user click on "Dynamo Player" Icon
+        /// </summary>
+        /// <remarks>Only occurs if icon associated commands has been binded</remarks>
+        private void OnDynamoPlayerIconClick(object sender, ExecutedEventArgs e)
+        {
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 1- Load Dynamo */
+                DynamoProducts.Load(v);
+            });
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 2- Start Dynamo Player (if we can) */
+                Version currentversion = ProductsManager.LoadedProduct();
+                if (currentversion == Product.NODYNAMO) throw new ArgumentException($"{v} is not loaded");
+                UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
+                var dynamoPlayerCmdId = RevitCommandId.LookupCommandId(CommandsBinders.PLAYERID);
+                uiApp.PostCommand(dynamoPlayerCmdId);
+            });
+
+            dlg.Show();
+        }
+
+        /// <summary>
+        /// Event when user click on "Version selection" icon
+        /// </summary>
+        /// <remarks>"Version selection" icon may not be present</remarks>
+        private void OnDynamoVersionIconClick()
+        {
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.AddNoDynamoOption();
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v)
             {
-                DynamoProducts.Load(version);
-                return Result.Succeeded;
-            }
-            catch (Exception) { /* */ }
+                /* Load Dynamo */
+                var ret = DynamoProducts.Load(v);
+                if (!ret.IsSucceed)
+                    return;
+            
+                /* Save Result */
+                Tools.Presistence.ActiveVersion = v;
+                
+                /* UI Confirmation */
+                if (ret.fromVersion != ret.afterVersion)
+                {
+                    var popup = new TaskDialog(Resources.DynamoVersions);
+                    popup.MainInstruction = Resources.DynamoVersionSelection;
+                    if (ret.Result == ProductsManager.LoadResult.ResultType.PENDING)
+                    {
+                        /* Need to restart Revit */
+                        popup.MainContent = String.Format(Resources.NeedToRestartRevit);
+                        if (ret.afterVersion != Product.NODYNAMO)
+                            popup.MainContent = String.Format(Resources.ProductNeedToRestartRevit, ret.afterVersion);
+                    }
+                    else
+                    {
+                        popup.MainContent = String.Format(Resources.ProductLoaded, ret.afterVersion);
+                    }
+                    popup.Show();
+                }
+            });
 
-            return Result.Failed;
+            dlg.Show();
         }
 
         public Result OnShutdown(UIControlledApplication application)
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
index 24f0724e09..484ee1f2e3 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
@@ -3,22 +3,15 @@
 using Autodesk.Revit.UI;
 using System.Linq;
 using DynamoRevitVersionSelector.Properties;
+using Autodesk.Revit.UI.Events;
+using Dynamo.Applications.Tools;
 
 namespace Dynamo.Applications
 {
     internal class VersionSelectorButton
     {
-        private List<Product> mProductList;
-        private UIControlledApplication uiControlledApplication;
-
-        public delegate Result OnVersionSelectedEventHandler(Version version);
-        public event OnVersionSelectedEventHandler OnVersionSelected;
-
-        public VersionSelectorButton(UIControlledApplication application, List<Product> ProductList)
-        {
-            uiControlledApplication = application;
-            mProductList = ProductList;
-        }
+        public delegate void OnClickEventHandler();
+        public event OnClickEventHandler OnButtonClick;
 
         public void AddInRibbon()
         {
@@ -30,60 +23,15 @@ public void AddInRibbon()
                     btn.Text = Resources.VersionSelectionBtnText;
                     btn.ToolTip = Resources.VersionSelectionBtnToolTip;
                     btn.Image = Resources.dynamo_setting_32x32;
-                    btn.OnClickEvent += OnClick;
+                    btn.OnClickEvent += ButtonClick;
                     panel.Source.Items.Add(btn.Source);
                 }
             }
         }
 
-        private void OnClick()
+        private void ButtonClick()
         {
-            // Latest version available
-            Version latestVersion = mProductList.First().Version;
-
-            // Current Version loaded in appDomain
-            Version currentVersion = latestVersion;
-            var isCurrentVersion = ProductsManager.IsProductLoaded(ref currentVersion);
-
-            // Selected Version
-            Version selectedVersion = Tools.Presistence.ActiveVersion;
-            if (selectedVersion == Product.LASTESTDYNAMO) selectedVersion = latestVersion;
-
-            // Creates a Revit task dialog to communicate information to the user.
-            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
-            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
-            mainDialog.MainContent = Resources.VersionSelectionContent;
-
-            // Add commmandLink options to task dialog
-            int id = (int)TaskDialogCommandLinkId.CommandLink1;
-            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
-            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
-            foreach (var item in mProductList)
-            {
-                item.isCurrent = (item.Version == currentVersion);
-                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, item.Title, item.SubTitle);
-                if (item.Version == selectedVersion) defaultResult = (TaskDialogResult)id;
-                id++;
-            }
-            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
-            mainDialog.DefaultButton = defaultResult;
-
-            TaskDialogResult tResult = mainDialog.Show();
-            if (tResult == TaskDialogResult.Close)
-                return;
-
-            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
-            try
-            {
-                var version = mProductList[index].Version;
-                if (version == latestVersion) version = Product.LASTESTDYNAMO;
-
-                // Save Result
-                Tools.Presistence.ActiveVersion = version;
-                OnVersionSelected(version);
-            }
-            catch (Exception) { /* */ }
-
+            OnButtonClick();
         }
     }
 }

From 4be54265c1b380e9c635806962c442d1c1575265 Mon Sep 17 00:00:00 2001
From: Jan D''Orgeville <jdorgeville@spiria.com>
Date: Tue, 12 Jun 2018 14:25:10 -0400
Subject: [PATCH 4/4] Bug Fix: Remove unexpected version Picker if only one
 product is available

---
 .../ProductsManager.cs                        | 14 ++++++++-
 .../VersionSelectorApp.cs                     | 29 ++++++++++++-------
 2 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
index d2734dce0b..db02d7ecbc 100644
--- a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
@@ -49,6 +49,18 @@ public List<Product> List
             }
         }
 
+        /// <summary>
+        /// Accessor to return the most recent Dyanmo Product.
+        /// </summary>
+        /// <seealso cref="Contains"/>
+        public Product Latest
+        {
+            get
+            {
+                return this.List.First();
+            }
+        }
+
         /// <summary>
         /// Number of Dyanmo Products available
         /// </summary>
@@ -193,7 +205,7 @@ public LoadResult Load(Version version)
                 }
                 if (version == Product.LASTESTDYNAMO)
                 {
-                    product = this.List.First();
+                    product = this.Latest;
                     break;
                 }
 
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
index a810d2bcb0..3f6b41767d 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
@@ -48,24 +48,31 @@ public Result OnStartup(UIControlledApplication application)
             activeVersion = Tools.Presistence.ActiveVersion;
             if ((activeVersion != Product.LASTESTDYNAMO) && (!DynamoProducts.Contains(activeVersion)))
                 activeVersion = Product.NODYNAMO; // default
-            
+
             // Write it back to keep consistency
             Tools.Presistence.ActiveVersion = activeVersion;
 
-
-            if (activeVersion == Product.NODYNAMO)
+            // Multiple Revit Product without any persisted version ?
+            if (DynamoProducts.Count > 1 && activeVersion == Product.NODYNAMO)
             {
                 Commands.Bind();
+                return Result.Succeeded;
             }
-            else
+
+            // Single Revit Version
+            if (DynamoProducts.Count == 1)
             {
-                // load expected product
-                var ret = DynamoProducts.Load(activeVersion);
-                if (!ret.IsSucceed) {
-                    /* Error, go back in a safe position for the next time */
-                    Tools.Presistence.ActiveVersion = Product.NODYNAMO;
-                    return Result.Failed;
-                }
+                Tools.Presistence.ActiveVersion = Product.NODYNAMO; // back to default
+                activeVersion = DynamoProducts.Latest.Version; // force to use the unique version available
+            }
+
+
+            // load expected product
+            var ret = DynamoProducts.Load(activeVersion);
+            if (!ret.IsSucceed) {
+                /* Error, go back in a safe position for the next time */
+                Tools.Presistence.ActiveVersion = Product.NODYNAMO;
+                return Result.Failed;
             }
 
             return Result.Succeeded;