/// <summary>
        /// Initializes a new instance of the StringSequenceFeedSourceStore class.
        /// </summary>
        /// <param name="preferences">IStringSequenceStore instance.</param>
        /// <param name="filterTag">Gallery filter tag for the feed sources.</param>
        public StringSequenceFeedSourceStore(IPreferences preferences, string filterTag)
            : base(preferences)
        {
            _filterTag = filterTag;

            _stringSequenceStore = new StringSequenceStore(this.Preferences);
        }

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="Tasque.Core.BackendManager"/> class.
        /// </summary>
        /// <param name='preferences'>
        /// Preferences.
        /// </param>
        /// <exception cref="T:System.ArgumentNullException">
        /// thrown when preferences is <c>null</c>.
        /// </exception>
        public BackendManager(IPreferences preferences)
        {
            manager = new InternalBackendManager (preferences);

            // setup backend manager for AllList
            Tasque.Utils.AllList.SetBackendManager (this);
        }

		public RecentFilesProvider (IPreferences prefs)
		{
			NumRecentDocs = prefs.Get<int> ("NumRecentDocs", 7);
			
			RefreshRecentDocs ();
			Gtk.RecentManager.Default.Changed += delegate { RefreshRecentDocs (); };
		}

 public RenderPackageFactoryViewModel(IPreferences preferenceSettings)
 {
     this.factory = new HelixRenderPackageFactory()
     {
         TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges }
     };
 }

 public ConnectionManager(IPreferences preferences, IPowerManager powerManager, IConnectionInfo connectionInfo, IBlackoutTime blackoutTime)
 {
     Preferences = preferences;
     PowerManager = powerManager;
     ConnectionInfo = connectionInfo;
     BlackoutTime = blackoutTime;
 }

 /// <summary>
 /// Enables starting Dynamo with a mock IUpdateManager
 /// </summary>
 /// <param name="updateManager"></param>
 /// <param name="watchHandler"></param>
 /// <param name="preferences"></param>
 /// <param name="visualizationManager"></param>
 protected void StartDynamo(IUpdateManager updateManager, ILogger logger, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
 {
     //create a new instance of the ViewModel
     Controller = new DynamoController(Context.NONE, updateManager, logger, watchHandler, preferences);
     Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
     DynamoController.IsTestMode = true;
     Controller.VisualizationManager = new VisualizationManager();
 }

		public Connection (IPreferences preferences)
		{
			if (null == preferences) {
				throw new ArgumentNullException ("preferences");
			}
			this.preferences = preferences;
			this.cookies = new CookieCollection ();
		}

 public NuGetFeedSourceStore(IPreferences preferences)
     : base(preferences)
 {
     _packageSourceProvider = new PackageSourceProvider(
         // Do not load user settings or machine wide settings for WebMatrix 'nuget.org' feed
         // In other words, pass all null to LoadDefaultSettings
         Settings.LoadDefaultSettings(null, null, null),
         defaultSources: new[] { new PackageSource("https://www.nuget.org/api/v2", Resources.NuGet_PackageSourceName) });
 }

        public static void GetPreferences(this ModbusAdaptersViewModel modbusAdaptersViewModel, IPreferences preferences, string key)
        {
            var selectedPort = modbusAdaptersViewModel.SelectedPort;

            if (selectedPort != null)
            {
                preferences[key] = selectedPort;
            }
        }

 private void ScanAllPackageDirectories(IPreferences preferences)
 { 
     foreach (var dir in 
         Directory.EnumerateDirectories(RootPackagesDirectory, "*", SearchOption.TopDirectoryOnly))
     {
         var pkg = ScanPackageDirectory(dir);
         if (preferences.PackageDirectoriesToUninstall.Contains(dir)) pkg.MarkForUninstall(preferences);
     }
 }

 public void Load(IPreferences preferences, IPathManager pathManager)
 {
     // Load Packages
     PackageLoader.DoCachedPackageUninstalls(preferences);
     PackageLoader.LoadAll(new LoadPackageParams
     {
         Preferences = preferences,
         PathManager = pathManager
     });
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="StartupParams"/> class.
 /// </summary>
 /// <param name="provider"><see cref="IAuthProvider"/> for DynamoModel</param>
 /// <param name="pathManager"><see cref="IPathManager"/> for DynamoModel</param>
 /// <param name="libraryLoader"><see cref="ILibraryLoader"/> for DynamoModel</param>
 /// <param name="customNodeManager"><see cref="ICustomNodeManager"/> for DynamoModel</param>
 /// <param name="dynamoVersion"><see cref="Version"/> for DynamoModel</param>
 /// <param name="preferences"><see cref="IPreferences"/> for DynamoModel</param>
 public StartupParams(IAuthProvider provider, IPathManager pathManager,
     ILibraryLoader libraryLoader, ICustomNodeManager customNodeManager,
     Version dynamoVersion, IPreferences preferences)
 {
     this.authProvider = provider;
     this.pathManager = pathManager;
     this.libraryLoader = libraryLoader;
     this.customNodeManager = customNodeManager;
     this.dynamoVersion = dynamoVersion;
     this.preferences = preferences;
 }

        public InternalBackendManager(IPreferences preferences)
        {
            if (preferences == null)
                throw new ArgumentNullException ("preferences");
            this.preferences = preferences;

            availableBackendNodes = AddinManager
                .GetExtensionNodes<BackendNode> (typeof(IBackend));

            taskLists = new TaskListCollection ();
        }

        public static void ApplyPreferences(this ModbusAdaptersViewModel modbusAdaptersViewModel, IPreferences preferences, string key)
        {
            var displayName = preferences[key];

            var item = modbusAdaptersViewModel.Ports.FirstOrDefault(a => string.Compare(a, displayName, true) == 0);

            if (item != null)
            {
                modbusAdaptersViewModel.SelectedPort = item;
            }
        }

		public void Initialize (IPreferences preferences)
		{
			if (preferences == null)
				throw new ArgumentNullException ("preferences");
			this.preferences = preferences;

			// *************************************
			// AUTHENTICATION to Remember The Milk
			// *************************************
			string authToken = preferences.Get (PreferencesKeys.AuthTokenKey);
			if (authToken != null) {
				Logger.Debug ("Found AuthToken, checking credentials...");
				try {
					Rtm = new RtmNet.Rtm (ApiKey, SharedSecret, authToken);
					rtmAuth = Rtm.AuthCheckToken (authToken);
					Timeline = Rtm.TimelineCreate ();
					Logger.Debug ("RTM Auth Token is valid!");
					Logger.Debug ("Setting configured status to true");
					IsConfigured = true;
				} catch (RtmNet.RtmApiException e) {
					preferences.Set (PreferencesKeys.AuthTokenKey, null);
					preferences.Set (PreferencesKeys.UserIdKey, null);
					preferences.Set (PreferencesKeys.UserNameKey, null);
					Rtm = null;
					rtmAuth = null;
					Logger.Error ("Exception authenticating, reverting "
					              + e.Message);
				} catch (RtmNet.ResponseXmlException e) {
					Rtm = null;
					rtmAuth = null;
					Logger.Error ("Cannot parse RTM response. " +
						"Maybe the service is down. " + e.Message);
				} catch (RtmNet.RtmWebException e) {
					Rtm = null;
					rtmAuth = null;
					Logger.Error ("Not connected to RTM, maybe proxy: #{0}",
					              e.Message);
				} catch (System.Net.WebException e) {
					Rtm = null;
					rtmAuth = null;
					Logger.Error ("Problem connecting to internet: #{0}",
					              e.Message);
				}
			}

			if (Rtm == null) {
				Rtm = new RtmNet.Rtm (ApiKey, SharedSecret);
				if (NeedsConfiguration != null)
					NeedsConfiguration (this, EventArgs.Empty);
				return;
			}

			FinishInitialization ();
		}

        /// <summary>
        /// Enables starting Dynamo with a mock IUpdateManager
        /// </summary>
        /// <param name="updateManager"></param>
        /// <param name="watchHandler"></param>
        /// <param name="preferences"></param>
        /// <param name="visualizationManager"></param>
        protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
        {
            var corePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            DynamoPathManager.Instance.InitializeCore(corePath);

            //create a new instance of the ViewModel
            Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences, corePath);
            Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
            DynamoController.IsTestMode = true;
            Controller.VisualizationManager = new VisualizationManager();
        }

        /// <summary>
        ///     Scan the PackagesDirectory for packages and attempt to load all of them.  Beware! Fails silently for duplicates.
        /// </summary>
        public void LoadPackagesIntoDynamo( IPreferences preferences, LibraryServices libraryServices )
        {
            this.ScanAllPackageDirectories( preferences );

            foreach (var pkg in LocalPackages)
            {
                DynamoPathManager.Instance.AddResolutionPath(pkg.BinaryDirectory);
            }

            foreach (var pkg in LocalPackages)
            {
                pkg.LoadIntoDynamo(loader, logger, libraryServices);
            }
        }

        public PackagePathViewModel(IPreferences setting)
        {
            RootLocations = new ObservableCollection<string>(setting.CustomPackageFolders);
            this.setting = setting;

            AddPathCommand = new DelegateCommand(p => InsertPath());
            DeletePathCommand = new DelegateCommand(p => RemovePathAt((int) p), CanDelete);
            MovePathUpCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) - 1), CanMoveUp);
            MovePathDownCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) + 1), CanMoveDown);
            UpdatePathCommand = new DelegateCommand(p => UpdatePathAt((int) p));
            SaveSettingCommand = new DelegateCommand(CommitChanges);

            SelectedIndex = 0;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Tasque.Client.BackendManager"/> class.
        /// </summary>
        /// <param name='preferences'>The preferences.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <para>
        /// Thrown, when <paramref name="backendInfos"/> is <c>null</c> -or-
        /// </para>
        /// <para>
        /// when <paramref name="preferences"/> is <c>null</c>.
        /// </para>
        /// </exception>
        /// <exception cref="System.ArgumentException">
        /// Thrown, when <paramref name="backendInfos"/> is empty.
        /// </exception>
        public BackendManager(IEnumerable<BackendInfo> backendInfos, IPreferences preferences)
        {
            if (backendInfos == null)
                throw new ArgumentNullException ("backendInfos");
            if (!backendInfos.Any ())
                throw new ArgumentException ("backendInfos must at least have one element");
            if (preferences == null)
                throw new ArgumentNullException ("preferences");

            AvailableBackends = new ReadOnlyCollection<BackendInfo> (backendInfos.ToList ());
            this.preferences = preferences;

            taskLists = new TaskListCollection ();
            TaskLists = new ReadOnlyObservableCollection<ITaskList> (taskLists);
        }

		void IBackend.Initialize (IPreferences preferences)
		{
			if (preferences == null)
				throw new ArgumentNullException ("preferences");
			
			database = new Database ();
			database.Open ();

			taskListRepo = new SqliteTaskListRepository (database);
			taskRepo = new SqliteTaskRepository (database);
			noteRepo = new SqliteNoteRepository (database);

			IsInitialized = true;
			if (Initialized != null)
				Initialized (this, EventArgs.Empty);
		}