public PluginManagerDialog(Window parent,
						    PluginManager
						    manager)
                : base(Catalog.GetString("Plugins"),
								   parent,
								   DialogFlags.
								   Modal,
								   Catalog.GetString("Close"),
								   ResponseType.
								   None)
            {
                SetupTree ();
                foreach (PluginInfo info in manager.Plugins)
                {
                    if (info.Plugin == null)
                      {
                          continue;
                      }
                    store.AppendValues (info);
                }

                ScrolledWindow win = new ScrolledWindow ();
                  win.HscrollbarPolicy = PolicyType.Automatic;
                  win.VscrollbarPolicy = PolicyType.Automatic;
                  win.Child = tree;
                  VBox.PackStart (win, true, true, 4);
                  SetSizeRequest (400, 400);
                  VBox.ShowAll ();
            }

        static void Main(string[] args)
        {
            #region Discover succeed due to a compatible version

            Console.WriteLine("Discover all ISamplePlugin plugins with version > 1.0 and version < 1.9.3 ...");

            var pm = new PluginManager(Environment.CurrentDirectory + System.IO.Path.DirectorySeparatorChar + "SamplePlugin")
                .Register<ISamplePlugin.ISamplePlugin>(new Version(1, 0), new Version(1, 9, 3))
                    .Discover();

            var plugin = pm.GetPlugins<ISamplePlugin.ISamplePlugin>(p => p.GetType().Name == "SamplePlugin").FirstOrDefault();
            Console.WriteLine("Succeeded for: " + plugin.SampleMethod(1, ""));

            #endregion

            #region Discovering fail due to an incompatible version

            Console.WriteLine("");
            Console.WriteLine("Discover all ISamplePlugin plugins with version > 1.0 and version < 1.8 ...");

            pm = new PluginManager(Environment.CurrentDirectory + System.IO.Path.DirectorySeparatorChar + "SamplePlugin")
                .Register<ISamplePlugin.ISamplePlugin>(new Version(1, 0), new Version(1, 8));

            pm.OnPluginIncompatibleVersion += (sender, e) =>
            {
                Console.WriteLine("Failed: [{0}] is not between [{1}] and [{2}]", e.PluginVersion, e.MinVersion, e.MaxVersion);
            };
            pm.Discover(false); // do not throw an axception

            #endregion

            Console.ReadKey();
        }

        public override void Initialize()
        {
            // required so we can access property.Value
            //PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver();

            base.Initialize();

            // this is so the model factory looks into the test assembly
            _pluginManager = PluginManager.Current;
            PluginManager.Current = new PluginManager(false)
            {
                AssembliesToScan = _pluginManager.AssembliesToScan
                    .Union(new[] { typeof(PublishedContentTests).Assembly })
            };

            ApplicationContext.Current = new ApplicationContext(false) { IsReady = true };

            // need to specify a custom callback for unit tests
            // AutoPublishedContentTypes generates properties automatically
            // when they are requested, but we must declare those that we
            // explicitely want to be here...

            var propertyTypes = new[]
                {
                    // AutoPublishedContentType will auto-generate other properties
                    new PublishedPropertyType("umbracoNaviHide", 0, Guid.Parse(Constants.PropertyEditors.TrueFalse)), 
                    new PublishedPropertyType("selectedNodes", 0, Guid.Empty), 
                    new PublishedPropertyType("umbracoUrlAlias", 0, Guid.Empty), 
                    new PublishedPropertyType("content", 0, Guid.Parse(Constants.PropertyEditors.TinyMCEv3)), 
                    new PublishedPropertyType("testRecursive", 0, Guid.Empty), 
                };
            var type = new AutoPublishedContentType(0, "anything", propertyTypes);
            PublishedContentType.GetPublishedContentTypeCallback = (alias) => type;
        }

        internal static void Initialize()
        {
            if (mGlobalInstance == null)
            {
                mGlobalInstance = new PluginManager(true);
                mGlobalInstance.LoadPlugins(@"GlueView\Plugins");
            }

            if (mProjectInstance != null)
            {
                foreach (IPlugin plugin in ((PluginManager)mProjectInstance).mPluginContainers.Keys)
                {
                    ShutDownPlugin(plugin, PluginShutDownReason.GlueShutDown);
                }
            }

            mProjectInstance = new PluginManager(false);

            mInstances.Clear();
            mInstances.Add(mGlobalInstance);
            mInstances.Add(mProjectInstance);

            GluxManager.BeforeVariableSet += OnBeforeVariableSet;
            GluxManager.AfterVariableSet += OnAfterVariableSet;

            mProjectInstance.LoadPlugins(@"GlueView\Plugins");
        }

        public static void Main(string[] args)
        {
            TabsterEnvironment.CreateDirectories();

            // prepare logging
            var logDirectory = TabsterEnvironment.CreateEnvironmentDirectoryPath(TabsterEnvironmentDirectory.ApplicatonData, "Logs");
            Logging.SetLogDirectory(logDirectory);

            // log all the errors
            AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            {
                var ex = (Exception) e.ExceptionObject;
                Logging.GetLogger().Error(ex);
            };

            _pluginManager = new PluginManager(TabsterEnvironment.CreateEnvironmentDirectoryPath(TabsterEnvironmentDirectory.ApplicatonData, "Plugins"));

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            var assemblyGuid = ((GuidAttribute) Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (GuidAttribute), true)[0]).Value;
            var filename = Path.Combine(TabsterEnvironment.GetEnvironmentDirectoryPath(TabsterEnvironmentDirectory.ApplicatonData), string.Format("{0}.tmp", assemblyGuid));

            using (var instanceController = new TabsterSingleInstanceController(filename))
            {
                instanceController.Start(new ReadOnlyCollection<string>(args));
            }
        }

 public MessagePump(PluginManager plugins, ArrayList connections)
 {
     this._run = false;
     this._plugins = plugins;
     this.set_processors();
     this._connections = connections;
     this._run_lock = new object();
 }

 public void LoadValidDataReaderPlugin()
 {
     using (var pluginManager = new PluginManager(_pluginsDirectory))
     {
         pluginManager.DeployPluginAsync(_pluginAssemblyPath).Wait();
         Assert.AreEqual(1, pluginManager.Plugins.Count());
     }
 }

        public void Load_WhenThePluginExists_ReturnPluginInstance()
        {
            var pluginManager = new PluginManager(_addInRootPath);

            ICalculatorPlugin calculatorPlugin = pluginManager.Load<ICalculatorPlugin>();

            Assert.NotNull(calculatorPlugin);
        }

        public void Load_WhenTheTypeIsSpecified_ItIsLoaded()
        {
            var pluginManager = new PluginManager(AppDomain.CurrentDomain.BaseDirectory);

            FakeCalculatorPlugin fakePlugin = pluginManager.Load<FakeCalculatorPlugin>();

            Assert.NotNull(fakePlugin);
        }

        public void IsLoaded_WhenPluginIsLoaded_ReturnsTrue()
        {
            var pluginManager = new PluginManager(_addInRootPath);

            ICalculatorPlugin calculatorPlugin = pluginManager.Load<ICalculatorPlugin>();

            Assert.True(pluginManager.IsLoaded<ICalculatorPlugin>());
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ContextMenuBuilder"/> class.
        /// </summary>
        /// <param name="pluginManager">The plugin manager. This can be found on MainWindow.</param>
        /// <param name="mainWindow">The main window command interface. This can be found on mainwindow.</param>
        public ContextMenuBuilder(PluginManager pluginManager, IMainWindow mainWindow)
        {
            Util.ThrowIfParameterNull(pluginManager, "pluginManager");
            Util.ThrowIfParameterNull(pluginManager, "mainWindow");

            _pluginManager = pluginManager;
            _mainWindow = mainWindow;
        }

 public void Init()
 {
     LayoutBuilder = new DefaultLayoutBuilder();
     RenderManager = new RenderManager(LayoutBuilder);
     PluginManager = new PluginManager(RenderManager, LayoutBuilder);
     AmbilightManager = new AmbilightManager(RenderManager, LayoutBuilder);
     PowerManager = new PowerManager(RenderManager);
 }

 public static void GenerateAdditionalMethodsPluginCode(PluginManager pluginManager,
     ICodeBlock codeBlock, IElement element)
 {
     foreach (ComponentPluginPair cpp in GetPluginsIn(pluginManager))
     {
         GenerateWithException(cpp.Generator.GenerateAdditionalMethods, codeBlock, element, cpp.Plugin, pluginManager);
     }
 }

        public static void CallCodeGenerationStart(PluginManager pluginManager, IElement element)
        {
            foreach (ICodeGeneratorPlugin plugin in pluginManager.CodeGeneratorPlugins)
            {
                plugin.CodeGenerationStart(element);

            }
        }

        public void Configure_need_ConfigureServicesBefore()
        {
            var loaderMock = new Mock<IPluginLoader>();
            var target = new PluginManager(loaderMock.Object);

            Action init2 = () =>target.Configure(new Mock<IApplicationBuilder>().Object);

            Assert.Throws<InvalidOperationException>(init2);
        }

        public static void GenerateActivityPluginCode(CodeLocation codeLocation, PluginManager pluginManager,
            ICodeBlock codeBlock, IElement element)
        {

            foreach (ComponentPluginPair cpp in GetPluginsIn(pluginManager, codeLocation))
            {
                GenerateWithException(cpp.Generator.GenerateActivity, codeBlock, element, cpp.Plugin, pluginManager);
            }
        }

        public override void InitPlugin(PluginManager manager)
        {
            base.InitPlugin(manager);

            manager.MovieScraper.PreMovieInfoScrape += PreMovieInfoScraperAction;
            manager.MovieScraper.PostMovieInfoScrape += PostMovieInfoScraperAction;
            manager.MovieScraper.PreMovieImageScrape += PreMovieImageScraperAction;
            manager.MovieScraper.PostMovieImageScrape += PostMovieImageScraperAction;
        }

        public void Load_WhenTheSamePluginIsLoadedTwice_TheSameInstanceIsReturned()
        {
            var pluginManager = new PluginManager(AppDomain.CurrentDomain.BaseDirectory);

            FakeCalculatorPlugin firstLoad = pluginManager.Load<FakeCalculatorPlugin>();
            FakeCalculatorPlugin secondLoad = pluginManager.Load<FakeCalculatorPlugin>();

            Assert.Equal(firstLoad, secondLoad);
        }

        public void Configure_throw_argument_null()
        {
            var loaderMock = new Mock<IPluginLoader>();
            var target = new PluginManager(loaderMock.Object);

            Action init2 = () =>target.Configure(null);

            Assert.Throws<ArgumentNullException>("applicationBuilder", init2);
        }

        public void Load_WhenTwoVersionsOfThePluginAreLoaded_OperationIsSuccessfull()
        {
            var pluginManager = new PluginManager(AppDomain.CurrentDomain.BaseDirectory);

            FakeCalculatorPlugin plugin = pluginManager.Load<FakeCalculatorPlugin>();
            FakeAnotherCalculatorPlugin anotherPlugin = pluginManager.Load<FakeAnotherCalculatorPlugin>();

            Assert.NotNull(plugin);
            Assert.NotNull(anotherPlugin);
        }