public ShellView(
     IShellViewModel viewModel)
 {
     InitializeComponent();
     DataContext = viewModel;
     viewModel.Dispatcher = Dispatcher;
 }

        public CashFlowTypesViewModel(IShellViewModel shell, IDatabase database, IConfigurationManager configuration, ICachedService cashedService, IEventAggregator eventAggregator)
            : base(shell, database, configuration, cashedService, eventAggregator)
        {
            SuppressEvent = false;
            _cashFlows = new BindableCollectionExt<CashFlow>();
            _cashFlows.PropertyChanged += (s, e) =>
            {
                OnPropertyChanged(s, e);
                CachedService.Clear(CachedServiceKeys.AllCashFlows);
            };

            _cashFlowGroups = new BindableCollectionExt<CashFlowGroup>();
            _cashFlowGroups.PropertyChanged += (s, e) =>
            {
                if (SuppressEvent == true)
                {
                    return;
                }
                OnPropertyChanged(s, e);

                CachedService.Clear(CachedServiceKeys.AllCashFlowGroups);
                CachedService.Clear(CachedServiceKeys.AllCashFlows);
                var cashFlowGroup = s as CashFlowGroup;
                _cashFlows.Where(x => x.CashFlowGroupId == cashFlowGroup.Id)
                    .ForEach(x => x.Group = cashFlowGroup);
                NewCashFlowGroup = null;
                NewCashFlowGroup = CashFlowGroups.First();
            };
        }

 public DownloadAndUpgradeViewModel(IShellViewModel shell, IDatabase database, IConfigurationManager configuration, ICachedService cashedService, IEventAggregator eventAggregator)
     : base(shell, database, configuration, cashedService, eventAggregator)
 {
     _webClient = new WebClient();
     _webClient.DownloadFileCompleted += OnDownloadFileCompleted;
     _webClient.DownloadProgressChanged += OnDownloadProgressChanged;
 }

        public ShellView(IShellViewModel vm)
        {
            vm.FileProgressStatusChanged += OnFileProgressStatusChanged;
            vm.FileProgressChanged += OnFileProgressChanged;

            DataContext = vm;
            InitializeComponent();
        }

        public ShellView(IShellViewModel model, IMessageBus bus)
            : this()
        {
            _bus = bus;
            DataContext = model;

            Loaded += OnLoaded;
        }

 public BudgetViewModel(IShellViewModel shell, IDatabase database, IConfigurationManager configuration, ICachedService cashedService, IEventAggregator eventAggregator)
     : base(shell, database, configuration, cashedService, eventAggregator)
 {
     ExpensesViewModel   = IoC.Get<ExpensesViewModel>();
     RevenuesViewModel   = IoC.Get<RevenuesViewModel>();
     BudgetPlanViewModel = IoC.Get<BudgetPlanViewModel>();
     BudgetCalculatorViewModel = IoC.Get<BudgetCalculationsViewModel>();
 }

    public Shell(IShellViewModel viewModel) {
      InitializeComponent();
      ViewModel = viewModel;
/*
      MenuCanvas.SetValue(Canvas.LeftProperty, MainGrid.ActualWidth);
      MenuCanvas.SetValue(Canvas.TopProperty, 15.0);
*/

    }

 public ShellController(
     IShellViewModel shellViewModel,
     IShellView shellView,
     IMainController mainController)
 {
     _shellViewModel = shellViewModel;
     _shellView = shellView;
     _mainController = mainController;
     _shellView.ViewModel = _shellViewModel;
 }

 public void TestInitialize()
 {
     shell = Substitute.For<IShellViewModel>();
     serviceControl = Substitute.For<IServiceControl>();
     settingsProvider = Substitute.For<ISettingsProvider>();
     connection = Substitute.For<IServiceControlConnectionProvider>();
     container = RegisterContainer();
     storedSetting = GetReloadedSettings();
     settingsProvider.GetSettings<ProfilerSettings>().Returns(storedSetting);
     connectTo = new ServiceControlConnectionViewModel(settingsProvider, container) { Parent = shell }; //TODO: Do we need to pass the full container here?
 }

        public ShellView(IShellViewModel vm, IToolbarView toolbarView, ITaskBoardView taskBoardView)
            : this()
        {
            DataContext = vm;

            mainGrid.Children.Add(toolbarView.Element);
            Grid.SetRow(toolbarView.Element, 0);

            mainGrid.Children.Add(taskBoardView.Element);
            Grid.SetRow(taskBoardView.Element, 1);
        }

 public DefaultExceptionHandler(
     IWindowManagerEx windowManager, 
     IViewModelFactory screenFactory,
     IAppCommands appCommands, 
     IEventAggregator eventAggregator,
     IShellViewModel shell) 
     : base(windowManager, screenFactory)
 {
     _windowManager = windowManager;
     _appCommands = appCommands;
     _eventAggregator = eventAggregator;
     _shell = shell;
 }

        public ShellView(IShellViewModel vm, IMessageBus bus, IModuleResolver resolver, ISettings settings)
            : this()
        {
            _bus = bus;
            _resolver = resolver;
            _settings = settings;
            DataContext = vm;

            _bus.Listen<ActivateMainModuleMessage>().Subscribe(msg => ActivateMainModule(msg.ModuleName));
            _bus.Listen<NavigateMainModuleMessage>().Subscribe(msg => NavigateMainModule(msg.ModuleName));
            _bus.Listen<NavigateBackMainModuleMessage>().Where(_ => _navigationStack.Count > 0).Subscribe(
                _ => NavigateBack());

            _bus.Listen<SettingsChangedMessage>().Subscribe(OnSettingsChanged);
        }

		private void setup()
		{
			var ns = new NavigationService(this, Resource.Id.content_frame);
			navService = ns;

			ns.RegisterFragment<ISettingsViewModel, SettingsFragment>();
			ns.RegisterFragment<ILoginViewModel, LoginFragment>();
			ns.RegisterFragment<IHomeViewModel, HomeFragment>();

			ViewModelLocator.Container.RegisterInstance<INavigationService>(navService);
			var container = ViewModelLocator.Container;

			ISharedPreferences prefs =  PreferenceManager.GetDefaultSharedPreferences(this);
			var settings = new AppSettings(prefs);
			settings.ServerUrl = null;

			container.RegisterInstance<ISettings>(settings);

			vm = container.Resolve<IShellViewModel>();
			vm.PropertyChanged += vmPropertyChanged;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="OptionsViewModel"/> class.
        /// </summary>
        /// <param name="userSettingService">
        /// The user Setting Service.
        /// </param>
        /// <param name="shellViewModel">
        /// The shell View Model.
        /// </param>
        /// <param name="updateService">
        /// The update Service.
        /// </param>
        public OptionsViewModel(IUserSettingService userSettingService, IShellViewModel shellViewModel, IUpdateService updateService)
        {
            this.Title = "Options";
            this.userSettingService = userSettingService;
            this.shellViewModel = shellViewModel;
            this.updateService = updateService;
            this.OnLoad();

            this.SelectedTab = OptionsTab.General;
            this.UpdateMessage = "Click 'Check for Updates' to check for new versions";
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewModel"/> class.
        /// The viewmodel for HandBrakes main window.
        /// </summary>
        /// <param name="userSettingService">
        /// The User Setting Service
        /// </param>
        /// <param name="scanService">
        /// The scan Service.
        /// </param>
        /// <param name="encodeService">
        /// The encode Service.
        /// </param>
        /// <param name="presetService">
        /// The preset Service.
        /// </param>
        /// <param name="errorService">
        /// The Error Service
        /// </param>
        /// <param name="shellViewModel">
        /// The shell View Model.
        /// </param>
        /// <param name="updateService">
        /// The update Service.
        /// </param>
        /// <param name="notificationService">
        /// The notification Service.
        /// *** Leave in Constructor. *** 
        /// </param>
        /// <param name="whenDoneService">
        /// The when Done Service.
        /// *** Leave in Constructor. *** 
        /// </param>
        public MainViewModel(IUserSettingService userSettingService, IScanServiceWrapper scanService, IEncodeServiceWrapper encodeService, IPresetService presetService,
            IErrorService errorService, IShellViewModel shellViewModel, IUpdateService updateService, INotificationService notificationService,
            IPrePostActionService whenDoneService)
        {
            this.scanService = scanService;
            this.encodeService = encodeService;
            this.presetService = presetService;
            this.errorService = errorService;
            this.shellViewModel = shellViewModel;
            this.updateService = updateService;
            this.userSettingService = userSettingService;
            this.queueProcessor = IoC.Get<IQueueProcessor>();

            // Setup Properties
            this.WindowTitle = "HandBrake";
            this.CurrentTask = new EncodeTask();
            this.CurrentTask.PropertyChanged += this.CurrentTask_PropertyChanged;
            this.ScannedSource = new Source();

            // Setup Events
            this.scanService.ScanStared += this.ScanStared;
            this.scanService.ScanCompleted += this.ScanCompleted;
            this.scanService.ScanStatusChanged += this.ScanStatusChanged;
            this.queueProcessor.JobProcessingStarted += this.QueueProcessorJobProcessingStarted;
            this.queueProcessor.QueueCompleted += this.QueueCompleted;
            this.queueProcessor.QueueChanged += this.QueueChanged;
            this.queueProcessor.EncodeService.EncodeStatusChanged += this.EncodeStatusChanged;
            this.userSettingService.SettingChanged += this.UserSettingServiceSettingChanged;

            this.Presets = this.presetService.Presets;
            this.CancelScanCommand = new CancelScanCommand(this.scanService);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="OptionsViewModel"/> class.
 /// </summary>
 /// <param name="windowManager">
 /// The window manager.
 /// </param>
 /// <param name="userSettingService">
 /// The user Setting Service.
 /// </param>
 /// <param name="shellViewModel">
 /// The shell View Model.
 /// </param>
 public OptionsViewModel(IWindowManager windowManager, IUserSettingService userSettingService, IShellViewModel shellViewModel)
 {
     this.Title = "Options";
     this.userSettingService = userSettingService;
     this.shellViewModel = shellViewModel;
     this.OnLoad();
 }

 public ShellView(IShellViewModel viewModel)
     : this()
 {
     DataContext = viewModel;
 }

        public MainViewModel(IWindowManager windowManager, IUserSettingService userSettingService, IScan scanService, IEncode encodeService, IPresetService presetService,
            IErrorService errorService, IShellViewModel shellViewModel, IUpdateService updateService)
        {
            this.scanService = scanService;
            this.encodeService = encodeService;
            this.presetService = presetService;
            this.errorService = errorService;
            this.shellViewModel = shellViewModel;
            this.updateService = updateService;
            this.userSettingService = userSettingService;
            this.queueProcessor = IoC.Get<IQueueProcessor>(); // TODO Instance ID!

            // Setup Properties
            this.WindowTitle = "HandBrake";
            this.CurrentTask = new EncodeTask();
            this.ScannedSource = new Source();

            // Setup Events
            this.scanService.ScanStared += this.ScanStared;
            this.scanService.ScanCompleted += this.ScanCompleted;
            this.scanService.ScanStatusChanged += this.ScanStatusChanged;
            this.queueProcessor.JobProcessingStarted += this.QueueProcessorJobProcessingStarted;
            this.queueProcessor.QueueCompleted += this.QueueCompleted;
            this.queueProcessor.EncodeService.EncodeStatusChanged += this.EncodeStatusChanged;

            this.Presets = this.presetService.Presets;
        }

 public NormalLoadViewModel()
 {
     _startViewModel = ShellViewModel.Current;
     /*timer = new Timer();
     timer.Interval = 100;
     timer.Elapsed += TimerElapsed;
     timer.Start();
     ProgressValue = 0;*/
 }

 public void TestInitialize()
 {
     IoC.GetInstance = (type, s) => null;
     _mockSubsonicService = new MockSubsonicService();
     _mockNavigationService = new MockNavigationService();
     _mockToastNotificationService = new MockToastNotificationService();
     _mockDialogNotificationService = new MockDialogNotificationService();
     _mockStorageService = new MockStorageService();
     _mockWinRTWrappersService = new MockWinRTWrappersService();
     _mockPlayerControls = new MockPlayerControls();
     Subject = new ShellViewModel(_eventAggregator, _mockSubsonicService, _mockNavigationService,
         _mockToastNotificationService, _mockDialogNotificationService, _mockStorageService, _mockWinRTWrappersService)
         {
             PlayerControls = _mockPlayerControls
         };
 }