/// <summary>
		/// Initializes the singleton intances of the mod manager.
		/// </summary>
		/// <param name="p_gmdGameMode">The current game mode.</param>
		/// <param name="p_eifEnvironmentInfo">The application's envrionment info.</param>
		/// <param name="p_mrpModRepository">The mod repository from which to get mods and mod metadata.</param>
		/// <param name="p_dmrMonitor">The download monitor to use to track task progress.</param>
		/// <param name="p_frgFormatRegistry">The <see cref="IModFormatRegistry"/> that contains the list
		/// of supported <see cref="IModFormat"/>s.</param>
		/// <param name="p_mrgModRegistry">The <see cref="ModRegistry"/> that contains the list
		/// of managed <see cref="IMod"/>s.</param>
		/// <param name="p_futFileUtility">The file utility class.</param>
		/// <param name="p_scxUIContext">The <see cref="SynchronizationContext"/> to use to marshall UI interactions to the UI thread.</param>
		/// <param name="p_ilgInstallLog">The install log tracking mod activations for the current game mode.</param>
		/// <param name="p_pmgPluginManager">The plugin manager to use to work with plugins.</param>
		/// <returns>The initialized mod manager.</returns>
		/// <exception cref="InvalidOperationException">Thrown if the mod manager has already
		/// been initialized.</exception>
        public static ModManager Initialize(IGameMode p_gmdGameMode, IEnvironmentInfo p_eifEnvironmentInfo, IModRepository p_mrpModRepository, DownloadMonitor p_dmrMonitor, ActivateModsMonitor p_ammMonitor, IModFormatRegistry p_frgFormatRegistry, ModRegistry p_mrgModRegistry, FileUtil p_futFileUtility, SynchronizationContext p_scxUIContext, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager)	
		{
			if (m_mmgCurrent != null)
				throw new InvalidOperationException("The Mod Manager has already been initialized.");
            m_mmgCurrent = new ModManager(p_gmdGameMode, p_eifEnvironmentInfo, p_mrpModRepository, p_dmrMonitor, p_ammMonitor, p_frgFormatRegistry, p_mrgModRegistry, p_futFileUtility, p_scxUIContext, p_ilgInstallLog, p_pmgPluginManager);
			return m_mmgCurrent;
		}

        public ZvsEngine(IFeedback<LogEntry> feedback, IAdapterManager adapterManager, IPluginManager pluginManager,
            IEntityContextConnection entityContextConnection, TriggerRunner triggerRunner, ScheduledTaskRunner scheduledTaskRunner)
        {
            if (entityContextConnection == null)
                throw new ArgumentNullException("entityContextConnection");

            if (feedback == null)
                throw new ArgumentNullException("feedback");

            if (adapterManager == null)
                throw new ArgumentNullException("adapterManager");

            if (pluginManager == null)
                throw new ArgumentNullException("pluginManager");

            if (triggerRunner == null)
                throw new ArgumentNullException("triggerRunner");

            if (scheduledTaskRunner == null)
                throw new ArgumentNullException("scheduledTaskRunner");

            EntityContextConnection = entityContextConnection;
            Log = feedback;
            AdapterManager = adapterManager;
            PluginManager = pluginManager;
            TriggerRunner = triggerRunner;
            ScheduledTaskRunner = scheduledTaskRunner;
            Log.Source = "Zvs Engine";


            AppDomain.CurrentDomain.SetData("DataDirectory", Utils.AppDataPath);
        }

        /// <summary>
        /// Performs all the operations needed to init the plugin/App
        /// </summary>
        /// <param name="user">singleton instance of UserPlugin</param>
        /// <param name="rootPath">path where the config files can be found</param>
        /// <returns>true if the user is already logged in; false if still logged out</returns>
        public static bool InitApp(UserClient user, string rootPath, IPluginManager pluginManager)
        {
            if (user == null)
                return false;

            // initialize the config file
            Snip2Code.Utils.AppConfig.Current.Initialize(rootPath);
            log = LogManager.GetLogger("ClientUtils");
 
            // login the user
            bool res = user.RetrieveUserPreferences();
            bool loggedIn = false;
            if (res && ((!BaseWS.Username.IsNullOrWhiteSpaceOrEOF()) || (!BaseWS.IdentToken.IsNullOrWhiteSpaceOrEOF())))
            {
                LoginPoller poller = new LoginPoller(BaseWS.Username, BaseWS.Password, BaseWS.IdentToken, BaseWS.UseOneAll,
                                                        pluginManager);
                LoginTimer = new System.Threading.Timer(poller.RecallLogin, null, 0, AppConfig.Current.LoginRefreshTimeSec * 1000);
                loggedIn = true;
            }

            System.Threading.ThreadPool.QueueUserWorkItem(delegate
            {
                user.LoadSearchHistoryFromFile();
            }, null);

            //set the empty profile picture for search list results:
            PictureManager.SetEmptyProfilePic(rootPath);

            return loggedIn;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Game"/> class.
        /// </summary>
        /// <param name="application">The photon application instance the game belongs to.</param>
        /// <param name="gameId">The game id.</param>
        /// <param name="roomCache">The room cache the game belongs to.</param>
        /// <param name="pluginManager">plugin creator</param>
        /// <param name="pluginName">Plugin name which client expects to be loaded</param>
        /// <param name="environment">different environment parameters</param>
        /// <param name="executionFiber">Fiber which will execute all rooms actions</param>
        public Game(
            GameApplication application,
            string gameId,
            Hive.Caching.RoomCacheBase roomCache = null,
            IPluginManager pluginManager = null,
            string pluginName = "",
            Dictionary<string, object> environment = null,
            ExtendedPoolFiber executionFiber = null
            )
            : base(gameId,
                roomCache,
                null,
                GameServerSettings.Default.MaxEmptyRoomTTL,
                pluginManager,
                pluginName,
                environment,
                GameServerSettings.Default.LastTouchSecondsDisconnect * 1000,
                GameServerSettings.Default.LastTouchCheckIntervalSeconds * 1000,
                DefaultHttpRequestQueueOptions,
                executionFiber)
        {
            this.Application = application;

            if (this.Application.AppStatsPublisher != null)
            {
                this.Application.AppStatsPublisher.IncrementGameCount();
            }

            this.HttpForwardedOperationsLimit = GameServerSettings.Default.HttpForwardLimit;
        }

		/// <summary>
		/// A simple constructor that initializes the object with its dependencies.
		/// </summary>
		/// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param>
		/// <param name="p_modMod">The mod being installed.</param>
		/// <param name="p_ilgInstallLog">The install log to use to log file installations.</param>
		/// <param name="p_pmgPluginManager">The plugin manager.</param>
		/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
		/// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param>
		/// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param>
        /// <param name="p_UsesPlugins">Game using plugin or mods (True for plugins).</param>
		public ModFileUpgradeInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins)
            : base(p_gmiGameModeInfo, p_modMod, p_ilgInstallLog, p_pmgPluginManager, p_dfuDataFileUtility, p_tfmFileManager, p_dlgOverwriteConfirmationDelegate, p_UsesPlugins, null)
		{
			OriginallyInstalledFiles = new Set<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string strFile in InstallLog.GetInstalledModFiles(Mod))
				OriginallyInstalledFiles.Add(strFile.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
		}

        public MenuViewModel(IApplicationState state, IPluginManager pluginManager, IApplicationConfig config, IPresetsManager presetManager)
        {
            _pluginManager = pluginManager;
            _state = state;
            _config = config;
            _presetsManager = presetManager;

            //Commands
            _openCommand = new DelegateCommand(Open);
            _openFileCommand = new DelegateCommand(OpenFile);
            _openStreamCommand = new DelegateCommand(OpenStream);
            _openDiscCommand = new DelegateCommand(OpenDisc);
            _openDeviceCommand = new DelegateCommand(OpenDevice);
            _openProcessCommand = new DelegateCommand(OpenProcess);
            _browseSamplesCommand = new DelegateCommand(BrowseSamples);
            _exitCommand = new DelegateCommand(Exit);
            _changeFormatCommand = new DelegateCommand(SetStereoInput);
            _changeProjectionCommand = new DelegateCommand(SetProjection);
            _changeEffectCommand = new DelegateCommand(SetEffect);
            _changeLayoutCommand = new DelegateCommand(SetStereoOutput);
            _changeDistortionCommand = new DelegateCommand(SetDistortion);
            _changeTrackerCommand = new DelegateCommand(SetTracker);
            _saveMediaPresetCommand = new DelegateCommand(SaveMediaPreset);
            _saveDevicePresetCommand = new DelegateCommand(SaveDevicePreset);
            _saveAllPresetCommand = new DelegateCommand(SaveAllPreset);
            _loadMediaPresetCommand = new DelegateCommand(LoadMediaPreset);
            _resetPresetCommand = new DelegateCommand(ResetPreset);
            _settingsCommand = new DelegateCommand(ShowSettings);
            _launchWebBrowserCommand = new DelegateCommand(LaunchWebBrowser);
            _aboutCommand = new DelegateCommand(ShowAbout);
        }

 public PluginCompositeFileProvider(IPluginManager pluginManager, IFileProvider defaultFileProvider, string subfolder=null)
 {
     var pluginsFileProviders = new List<IFileProvider>(pluginManager.LoadedPlugins.Count()+1);
     pluginsFileProviders.Add(defaultFileProvider);
     pluginsFileProviders.AddRange(GetPluginFileProviders(pluginManager, subfolder));
     _fileProvider = new CompositeFileProvider(pluginsFileProviders);
 }

 private IEnumerable<IFileProvider> GetPluginFileProviders(IPluginManager pluginManager, string subfolder)
 {
     foreach (var pluginInfo in pluginManager.LoadedPlugins)
     {
         yield return new PluginFileProvider(pluginInfo, subfolder, null);
     }
 }

 public SettingsManager(IApplicationState state, IPluginManager pluginManager, IApplicationConfig config, ApplicationSettingsBase settings)
 {
     _settings = settings;
     _state = state;
     _pluginManager = pluginManager;
     _config = config;
 }

 public void Initialize(IPluginManager pluginManager)
 {
     foreach (var instance in pluginManager.Plugins<IBaseAjaxNamespace>().Select(ajaxNamespace => ajaxNamespace.Value))
     {
         this.RegisterNamespace(instance.PluginInfo["namespace"], instance);
     }
 }

		/// <summary>
		/// Initializes the singleton intances of the mod manager.
		/// </summary>
		/// <param name="p_gmdGameMode">The current game mode.</param>
		/// <param name="p_mprManagedPluginRegistry">The <see cref="PluginRegistry"/> that contains the list
		/// of managed <see cref="Plugin"/>s.</param>
		/// <param name="p_aplPluginLog">The <see cref="ActivePluginLog"/> tracking plugin activations for the
		/// current game mode.</param>
		/// <param name="p_polOrderLog">The <see cref="IPluginOrderLog"/> tracking plugin order for the
		/// current game mode.</param>
		/// <param name="p_povOrderValidator">The object that validates plugin order.</param>
		/// <exception cref="InvalidOperationException">Thrown if the plugin manager has already
		/// been initialized.</exception>
		public static IPluginManager Initialize(IGameMode p_gmdGameMode, PluginRegistry p_mprManagedPluginRegistry, ActivePluginLog p_aplPluginLog, IPluginOrderLog p_polOrderLog, IPluginOrderValidator p_povOrderValidator)
		{
			if (m_pmgCurrent != null)
				throw new InvalidOperationException("The Plugin Manager has already been initialized.");
			m_pmgCurrent = new PluginManager(p_gmdGameMode, p_mprManagedPluginRegistry, p_aplPluginLog, p_polOrderLog, p_povOrderValidator);
			return m_pmgCurrent;
		}

        public void Init(HttpApplication context)
        {
            context.PreRequestHandlerExecute += ContextOnBeginRequest;
            _pluginManager = Services.Get<IPluginManager>();

            _pluginManager.AfterConfigurationChanged += PluginManagerAfterConfigurationChanged;
        }

		/// <summary>
		/// A sinmple constructor that initializes the object with the given values.
		/// </summary>
		/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
		/// <param name="p_mfiFileInstaller">The installer to use to install files.</param>
		/// <param name="p_iniIniInstaller">The installer to use to install INI values.</param>
		/// <param name="p_gviGameSpecificValueInstaller">The installer to use to install game specific values.</param>
		/// <param name="p_pmgPluginManager">The manager to use to manage plugins.</param>
		public InstallerGroup(IDataFileUtil p_dfuDataFileUtility, IModFileInstaller p_mfiFileInstaller, IIniInstaller p_iniIniInstaller, IGameSpecificValueInstaller p_gviGameSpecificValueInstaller, IPluginManager p_pmgPluginManager)
		{
			DataFileUtility = p_dfuDataFileUtility;
			FileInstaller = p_mfiFileInstaller;
			IniInstaller = p_iniIniInstaller;
			GameSpecificValueInstaller = p_gviGameSpecificValueInstaller;
			PluginManager = p_pmgPluginManager;
		}

 public StebsHub(IConstants constants, IMpm mpm, IProcessorManager manager, IFileManager fileManager, IPluginManager pluginManager)
 {
     this.Constants = constants;
     this.Mpm = mpm;
     this.Manager = manager;
     this.FileManager = fileManager;
     this.PluginManager = pluginManager;
 }

 public TestGame(string roomId, Caching.RoomCacheBase parent, int emptyRoomTTL, IPluginManager eManager, string pluginName)
     : base(roomId, parent, new TestGameStateFactory(), emptyRoomTTL, eManager, pluginName)
 {
     //this.IsOpen = true;
     //this.IsVisible = true;
     //this.EventCache.SetGameAppCounters(NullHiveGameAppCounters.Instance);
     //this.EventCache.AddSlice(0);
 }

        public SettingsWindowViewModel(IApplicationState state, IApplicationConfig config, IPluginManager pluginManager)
        {
            _state = state;
            _config = config;
            _pluginManager = pluginManager;

            _changeSamplePathCommand = new DelegateCommand(ChangeSamplePath);
        }

 public LoginPoller(string username, string password, string identToken, bool useOneAll, IPluginManager pluginManager) 
 {
     this.username = username;
     this.password = password;
     this.identToken = identToken;
     this.useOneAll = useOneAll;
     this.pluginManager = pluginManager;
 }

 public ViewModelFactory(IApplicationConfig config, IPluginManager pluginManager, IApplicationState state, IPresetsManager presetsManager, IMediaService mediaService)
 {
     _config = config;
     _pluginManager = pluginManager;
     _state = state;
     _presetsManager = presetsManager;
     _mediaService = mediaService;
 }

 public DevelopmentManager(IEventManager eventManager, IPluginManager pluginManager)
 {
     // Create the logged in user's specific instance of the user manager proxy.
     // The actual implementation class could be changed in configuration
     // or using dependency injection (if we want to implement that)...
     _eventManager = eventManager;
     _pluginManager = pluginManager;
     _commonManagerProxy = new CommonManagerProxy(this);
 }

 public static RazorViewEngineOptions ConfigurePluginsView( this RazorViewEngineOptions options, IPluginManager pluginManager)
 {
     options.ViewLocationExpanders.Insert(0, new PluginViewLocationExtender());
     foreach (var pluginInfo in pluginManager.LoadedPlugins)
     {
         options.FileProviders.Add(new PluginFileProvider(pluginInfo, "Views", "Views"));
     }
     return options;
 }