private MainViewModel PrepareMainViewModel(ClientStorage clientStorage, ProjectStorage projectStorage)
 {
     var clientListViewModel = new ClientListViewModel(clientStorage);
     var projectListViewModel = new ProjectListViewModel(projectStorage);
     var mainViewModel = new MainViewModel(clientListViewModel, projectListViewModel);
     return mainViewModel;
 }

 /// <summary>
 /// Provides a deterministic way to create the Main property.
 /// </summary>
 public static void CreateMain()
 {
     if (_main == null)
     {
         _main = new MainViewModel();
     }
 }

        public void SaveCommandExecutedWhereSaveCallbackIsNullExpectedNoException()
        {
            Configuration.Settings.Configuration config = new Configuration.Settings.Configuration("localhost");
            MainViewModel mainViewModel = new MainViewModel(config.ToXml(), null, null, null);

            mainViewModel.SaveCommand.Execute(null);
        }

        public MainWindow()
        {
            _mainViewModel = new MainViewModel();
            DataContext = _mainViewModel;

            InitializeComponent();
            AddNewLocation.Click += AddNewLocationClick;
            DeleteLocation.Click += DeleteLocationOnClick;

            AddNewSwitch.Click += AddNewSwitchClick;
            DeleteSwitch.Click += DeleteSwitchOnClick;
            AddNewLight.Click += AddNewLightClick;
            DeleteLight.Click += DeleteLightOnClick;

            AssignSwitchToLocation.Click += AssignSwitchToLocationClick;
            RemoveSwitchFromLocation.Click += RemoveSwitchFromLocationOnClick;

            AssignSwitchToLight.Click += AssignSwitchToLightClick;
            RemoveLightFromLocation.Click += RemoveLightFromLocationOnClick;

            AssignLightToLocation.Click += AssignLightToLocationClick;
            RemoveSwitchFromLight.Click += RemoveSwitchFromLightOnClick;

            AddNewArduinoGroup.Click += AddNewArduinoGroup_Click;
            DeleteArduinoGroup.Click += DeleteArduinoGroupOnClick;

            AssignLocationToArduinoGroup.Click += AssignLocationToArduinoGroupOnClick;
            RemoveLocationFromArduinoGroup.Click += RemoveLocationFromArduinoGroupOnClick;

            Open.Click += OpenOnClick;
            Save.Click += SaveOnClick;
            Generate.Click += GenerateOnClick;
            Print.Click += PrintOnClick;
        }

        public MapsViewModel(MainViewModel parent)
        {
            this.Parent = parent;

            var allMaps = parent.Realm.GameData.GetSheet<Map>();
            _Maps = allMaps.Where(m => m.TerritoryType != null && m.TerritoryType.Key > 1 && m.PlaceName != null && m.PlaceName.Key != 0 && m.RegionPlaceName != null && m.RegionPlaceName.Key != 0).ToArray();
        }

        public HomePage()
        {
            ViewModel = new MainViewModel(8);            
            InitializeComponent();

            NavigationCacheMode = NavigationCacheMode.Required;
        }

 public MainWindow(string imagePath)
 {
     InitializeComponent();
     mainVM = new MainViewModel(this.canvas, imagePath);
     this.DataContext = mainVM;
     moving = false;
 }

        public static void Run()
        {
            var window = new MainWindow();

            var viewModel = new MainViewModel(
                Properties.Settings.Default.LastFolder);

            viewModel.OnFolderChanged += (s, e) =>
            {
                Properties.Settings.Default.LastFolder = e.Item;

                Properties.Settings.Default.Save();
            };

            viewModel.OnLogon += (s, e) =>
            {
                var uri = LogonRunner.Run(window);

                if (uri != null)
                    viewModel.HandleLogon(uri);
            };

            window.DataContext = viewModel;

            window.Show();
        }

 public OutputWindow(DFABuilder dfaBuilder, bool stepByStepMode)
 {
     InitializeComponent();
     _dfa = dfaBuilder.Dfa;
     if (_dfa.States.Count >= 25)
     {
         MessageBox.Show("Warning! There are more than 25 states generated. The proper working of the application is not guaranteed.");
     }
     _mainViewModel = new MainViewModel();
     _dfaBuilder = dfaBuilder;
     this.DataContext = _mainViewModel;
     _steps = dfaBuilder.Steps;
     if (stepByStepMode)
     {
         btnNextStep.IsEnabled = true;
     }
     else
     {
         btnNextStep.IsEnabled = false;
         generateContentDot(_steps.Count);
         BitmapImage bmp = dot2bmp(_beginDot + _contentDot + _endDot);
         imgGraph.Source = bmp;
         foreach (Transition t in _dfa.Transitions)
         {
             _mainViewModel.Transitions.Add(t);
         }
         foreach (State s in _dfa.States)
         {
             _mainViewModel.Labels.Add(Tuple.Create(s.QLabel, s.RegexLabel));
         }
     }
 }

		public static void LoadWSOFile(string filePath, MainViewModel viewModel)
		{
			// Load user's current options and make a copy.
			BuildModel(viewModel, false);

			IVisitorWithContext visitor = new XmlReadVisitor();
			UIOptionRootType optionsRoot = new UIOptionRootType();
			optionsRoot.Accept(visitor, filePath);

			foreach (var cat in optionsRoot.Categories)
			{
				foreach (var subCat in cat.SubCategories)
				{
					foreach (var opt in subCat.Options)
					{
						if (opt is UIOptionGroupType)
						{
							LoadGroup(viewModel, opt);
						}
						IOption targetOpt = viewModel.FindOption(opt.Name);
						if (targetOpt != null)
						{
							LoadOption(targetOpt, opt);
						}
					}
				}
			}

			// We need to pass the OptionsRoot object to somebody who can display it in UI
		}

        public MainPage()
        {
            this.InitializeComponent();
            this.NavigationCacheMode = NavigationCacheMode.Enabled;

            // set data context
            _mainVm = SingletonLocator.Get<MainViewModel>();
            DataContext = _mainVm;

            // set initial items panel template (from settings)
            var iptIndex = new AppSettings().ItemsControlViewInfoIndex;
            SetItemsPanelTemplate(iptIndex);

            Loaded += MainPage_OnLoaded;

            // listen for back-button
            HardwareButtons.BackPressed += async (sender, args) =>
            {
                if (_mainVm.IsSortingControlVisible)
                {
                    _mainVm.ToggleSorterControlVisibility();
                    await _mainVm.ApplySortAsync();
                    args.Handled = true;
                }
            };
        }

 public MainPage()
 {
     this.InitializeComponent();
     mvm = MainViewModel.Instance;
     DataContext = mvm;          
     //System.Diagnostics.Debug.WriteLine(MainViewModel.GetInstanceOf().HueLampen.Count);            
 }

		public Issue1875()
		{
			Button loadData = new Button { Text = "Load", HorizontalOptions = LayoutOptions.FillAndExpand };
			ListView mainList = new ListView {
				VerticalOptions = LayoutOptions.FillAndExpand,
				HorizontalOptions = LayoutOptions.FillAndExpand
			};

			mainList.SetBinding (ListView.ItemsSourceProperty, "Items");

			_viewModel = new MainViewModel ();
			BindingContext = _viewModel;
			loadData.Clicked += async (sender, e) => {
				await LoadData ();
			};

			mainList.ItemAppearing += OnItemAppearing;

			Content = new StackLayout {
				Children = {
					loadData,
					mainList
				}
			};
		}

        public MobileTransactionsViewModel(MainViewModel mainViewModel)
        {
            _mainViewModel = mainViewModel;

            FromDateFilter = DateTime.Today.AddDays(-14);
            ThroughDateFilter = DateTime.Today.AddDays(1);

            SalesmanFilter = mainViewModel.Context.Salesmen.ToList();
            SalesmanFilter.Insert(0, new Salesman { Contragent = new Contragent { LastName = "Any" } });
            SelectedSalesmanFilter = SalesmanFilter.FirstOrDefault();

            //ClientsFilter = mainViewModel.Context.Clients.ToList().Select(x => x.Contragent).ToList();
            //ClientsFilter.Insert(0, new Contragent { LastName = "Any" });
            //SelectedClientFilter = ClientsFilter.FirstOrDefault();

            ClientsFilter = mainViewModel.Context.Clients.ToList().Select(x => x.Contragent.LastName).ToList();

            MobileTransactions = new ObservableCollection<MobileTransactionViewModel>(GetMobileTransactions(mainViewModel.Context));
            MobileTransactionsView = CollectionViewSource.GetDefaultView(MobileTransactions);
            MobileTransactionsView.Filter = Filter;

            AddCommand = new DelegateCommand(Add);
            CloseAddDialogCommand = new DelegateCommand(() => AddDialogViewModel = null);

            DeleteCommand = new DelegateCommand(Delete, () => SelectedTransaction != null);

            FilterCommand = new DelegateCommand(MobileTransactionsView.Refresh);
        }

        public ApplicationController(CompositionContainer container, IPresentationService presentationService,
            IMessageService messageService, ShellService shellService, ProxyController proxyController, DataController dataController)
        {
            InitializeCultures();
            presentationService.InitializeCultures();

            this.container = container;
            this.dataController = dataController;
            this.proxyController = proxyController;
            this.messageService = messageService;

            this.dataService = container.GetExportedValue<IDataService>();

            this.floatingViewModel = container.GetExportedValue<FloatingViewModel>();
            this.mainViewModel = container.GetExportedValue<MainViewModel>();
            this.userBugsViewModel = container.GetExportedValue<UserBugsViewModel>();
            this.teamBugsViewModel = container.GetExportedValue<TeamBugsViewModel>();

            shellService.MainView = mainViewModel.View;
            shellService.UserBugsView = userBugsViewModel.View;
            shellService.TeamBugsView = teamBugsViewModel.View;

            this.floatingViewModel.Closing += FloatingViewModelClosing;

            this.showMainWindowCommand = new DelegateCommand(ShowMainWindowCommandExcute);
            this.englishCommand = new DelegateCommand(() => SelectLanguage(new CultureInfo("en-US")));
            this.chineseCommand = new DelegateCommand(() => SelectLanguage(new CultureInfo("zh-CN")));
            this.settingCommand = new DelegateCommand(SettingDialogCommandExcute, CanSettingDialogCommandExcute);
            this.aboutCommand = new DelegateCommand(AboutDialogCommandExcute);
            this.exitCommand = new DelegateCommand(ExitCommandExcute);
        }

        public RepairedToRepairProductDialogViewModel(MainViewModel mainViewModel)
        {
            _mainViewModel = mainViewModel;
            _repairedProduct = mainViewModel.ToRepairProductsViewModel.SelectedProduct;

            RepairedProductCommand = new DelegateCommand(RepairedProduct, Validate);
        }

        public ApplicationController(IEnvironmentService environmentService, IPresentationService presentationService, ShellService shellService,
            Lazy<FileController> fileController, Lazy<RichTextDocumentController> richTextDocumentController, Lazy<PrintController> printController,
            Lazy<ShellViewModel> shellViewModel, Lazy<MainViewModel> mainViewModel, Lazy<StartViewModel> startViewModel)
        {
            // Upgrade the settings from a previous version when the new version starts the first time.
            if (Settings.Default.IsUpgradeNeeded)
            {
                Settings.Default.Upgrade();
                Settings.Default.IsUpgradeNeeded = false;
            }

            // Initializing the cultures must be done first. Therefore, we inject the Controllers and ViewModels lazy.
            InitializeCultures();
            presentationService.InitializeCultures();

            this.environmentService = environmentService;
            this.fileController = fileController.Value;
            this.richTextDocumentController = richTextDocumentController.Value;
            this.printController = printController.Value;
            this.shellViewModel = shellViewModel.Value;
            this.mainViewModel = mainViewModel.Value;
            this.startViewModel = startViewModel.Value;

            shellService.ShellView = this.shellViewModel.View;
            this.shellViewModel.Closing += ShellViewModelClosing;
            this.exitCommand = new DelegateCommand(Close);
        }

		public void ConstructorSuccess()
		{
			InitializeDependencies ();
			var viewModel = new MainViewModel (_dataClientMock.Object, _appConfigMock.Object);

			Assert.IsNotNull (viewModel);
		}			

		public static bool SaveOptions(OptionsFileType fileType, string filePath, MainViewModel viewmodel, OSPlatformEnum osPlatform, RegistryTargetEnum registryTarget, DeploymentTypeEnum deploymentType)
		{
			bool result = false;
			switch (fileType)
			{
			case OptionsFileType.ADM:
				if (deploymentType == DeploymentTypeEnum.New)
				{
					result = SaveCleanADMFile(filePath, viewmodel, osPlatform, registryTarget);
				}
				else
				{
					result = SaveADMFile(filePath, viewmodel, osPlatform, registryTarget);
				}
				break;
			case OptionsFileType.REG:
				if (deploymentType == DeploymentTypeEnum.New)
				{
					result = SaveCleanREGFile(filePath, viewmodel, osPlatform, registryTarget);
				}
				else
				{
					result = SaveREGFile(filePath, viewmodel, osPlatform, registryTarget);
				}
				break;
			case OptionsFileType.WSO:
				result = SaveWSOFile(filePath, viewmodel);
				break;
			}
			return result;
		}

        public void WindowClosed_WillStoreCurrentWindowPositionToWindowConfig_Always()
        {
            var mainVM = new MainViewModel();
            var configGuard = new ConfigurableWindowGuard();
            var win1 = new Mock<IConfigurableWindow>();
            var win2 = new Mock<IConfigurableWindow>();
            configGuard.Init(mainVM);
            var winConfig1 = new Fake_WindowConfiguration("win1");
            var winConfig2 = new Fake_WindowConfiguration("win2");
            var win1Rect = new Rect(10, 20, 100, 200);
            var win2Rect = new Rect(30, 40, 300, 400);
            win1.Setup(window => window.GetPlacement()).Returns(win1Rect);
            win2.Setup(window => window.GetPlacement()).Returns(win2Rect);
            win1.Setup(window => window.GetAlwaysOnTop()).Returns(false);
            win2.Setup(window => window.GetAlwaysOnTop()).Returns(false);
            configGuard.RegisterConfigurableWindow(win1.Object, winConfig1);
            configGuard.RegisterConfigurableWindow(win2.Object, winConfig2);

            win1.Raise(window => window.ConfigurableWindowClosed += null, EventArgs.Empty);
            win2.Raise(window => window.ConfigurableWindowClosed += null, EventArgs.Empty);

            Assert.AreEqual((int)win1Rect.Left,   winConfig1.SettingsSaved["Left"]);
            Assert.AreEqual((int)win1Rect.Top,    winConfig1.SettingsSaved["Top"]);
            Assert.AreEqual((int)win1Rect.Width,  winConfig1.SettingsSaved["Width"]);
            Assert.AreEqual((int)win1Rect.Height, winConfig1.SettingsSaved["Height"]);
            Assert.AreEqual(0 /*false*/, winConfig1.SettingsSaved["IsTopMostWindow"]);
            Assert.AreEqual((int)win2Rect.Left,   winConfig2.SettingsSaved["Left"]);
            Assert.AreEqual((int)win2Rect.Top,    winConfig2.SettingsSaved["Top"]);
            Assert.AreEqual((int)win2Rect.Width,  winConfig2.SettingsSaved["Width"]);
            Assert.AreEqual((int)win2Rect.Height, winConfig2.SettingsSaved["Height"]);
            Assert.AreEqual(0 /*false*/, winConfig2.SettingsSaved["IsTopMostWindow"]);
        }