init

DTS Viewer/DTS.Viewer.Loader/.svn/pristine/63/639aeeafc4a6e76116dd38edac9095179534a2ac.svn-base

@@ -0,0 +1,117 @@
+using System;
+using System.Windows;
+using DTS.Common;
+using DTS.Common.Interface;
+using DTS.Common.Core.PluginLib;
+using Microsoft.Practices.Prism.Events;
+using Microsoft.Practices.Prism.Modularity;
+using Microsoft.Practices.Prism.Regions;
+using Microsoft.Practices.Prism.UnityExtensions;
+using Microsoft.Practices.ServiceLocation;
+using Microsoft.Practices.Unity;
+// ReSharper disable InconsistentNaming
+namespace DTS.Viewer.Loader
+{
+    /// <summary>
+    /// https://msdn.microsoft.com/en-us/library/ff921075(v=pandp.20).aspx
+    /// </summary>
+    public class Bootstrapper : UnityBootstrapper
+    {
+        public IServiceLocator _serviceLocator { get; private set; }
+        public IEventAggregator _EventAggregator { get; private set; }
+
+        protected override void ConfigureContainer()
+        {
+            Container.RegisterType<IShellView, ShellView>();
+            Container.RegisterType<IShellViewModel, ShellViewModel>(new ContainerControlledLifetimeManager());
+
+            try
+            {
+                base.ConfigureContainer();
+            }
+            catch (System.Threading.SynchronizationLockException e)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Returns null - not to interfere with Viewer app RegionAdapterMappings
+        /// </summary>
+        /// <returns></returns>
+        protected override RegionAdapterMappings ConfigureRegionAdapterMappings()
+        {
+            return null;
+            //var regionAdapterMappings = base.ConfigureRegionAdapterMappings();
+            //regionAdapterMappings.RegisterMapping(typeof(StackPanel), ServiceLocator.Current.GetInstance<StackPanelRegionAdapter>());
+            //return regionAdapterMappings;
+        }
+
+        /// <summary>
+        /// The CreateShell method allows a developer to specify the top-level window for a Prism application. 
+        /// The shell is usually the MainWindow or MainPage. Implement this method by returning an instance of 
+        /// your application's shell class. In a Prism application, you can create the shell object, or resolve 
+        /// it from the container, depending on your application's requirements.
+        /// </summary>
+        /// <returns></returns>
+        protected override DependencyObject CreateShell()
+        {
+            Container = ServiceLocator.Current.GetInstance<IUnityContainer>();
+            _EventAggregator = Container.Resolve<IEventAggregator>();
+            _serviceLocator = Container.Resolve<IServiceLocator>();
+
+            var viewmodel = Container.TryResolve<IShellViewModel>();
+            if (viewmodel == null) return new DependencyObject();
+
+            var view = viewmodel.View;
+
+            viewmodel.Initialize(this);
+
+            ((ShellView)view).Visibility = Visibility.Visible;
+
+            ((ShellView)view).Closing += Bootstrapper_Closing;
+            view.DataContext = viewmodel;
+            return ServiceLocator.Current.GetInstance<ShellView>();
+        }
+
+        /// <summary>
+        /// Shutdown the application
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void Bootstrapper_Closing(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            Application.Current.Shutdown(1);
+        }
+
+        /// <summary>
+        /// Returns the module catalog that will be used to initialize the modules.
+        /// </summary>
+        /// <returns>
+        /// An instance of <see cref="IModuleCatalog"/> that will be used to initialize the modules.
+        /// </returns>
+        protected override IModuleCatalog CreateModuleCatalog()
+        {
+            // The module catalog is used by the ModuleManager and ModuleLoader components, which are responsible for downloading the modules.
+            return new AggregateModuleCatalog();
+        }
+        /// <summary>
+        ///  Modules are packages of functionality that can be independently developed, tested, and (optionally) deployed.
+        ///  In a composite application, modules must be discovered and loaded at run time by the host application. 
+        ///  The module catalog is used by the ModuleManager and ModuleLoader components, which are responsible for downloading the modules.
+        ///  Modules are copied to a directory as part of a post-build step. These modules are not referenced in the project and are discovered by inspecting a directory.
+        ///  Module projects have a post-build step to copy themselves into that directory.
+        /// </summary>
+        protected override void ConfigureModuleCatalog()
+        {
+            var directoryCatalog = new DirectoryModuleCatalog { ModulePath = Properties.Settings.Default.PluginFolder };
+            ((AggregateModuleCatalog)ModuleCatalog).AddCatalog(directoryCatalog);
+
+        }
+        protected override void InitializeModules()
+        {
+            // Register the  DataProRegionManager with Unity dependency injection container as a singleton.
+            Container.RegisterType<IDTSRegionManager, DTSRegionManager>(new ContainerControlledLifetimeManager(), new InjectionMember[] { });
+            base.InitializeModules();
+        }
+    }
+}