/// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel()
        {
            scoreStorage = new ScoreStorage();
            HighScores = new ObservableCollection<Score>(scoreStorage.GetScores());
            game = new Game();
            game.PlayerLost += GameOnPlayerLost;
            game.PlayerTooFast += GameOnPlayerTooFast;
            game.PlayerWon += GameOnPlayerWon;
            game.CountdownTick += GameOnCountdownTick;
            game.WaitForItStarted += GameOnWaitForItStarted;
            game.TapDanceStarted += GameOnTapDanceStarted;
            game.ButtonsCanBeClickedChanged += GameOnButtonsCanBeClickedChanged;

            patternTimer = new DispatcherTimer();
            patternTimer.Tick += PatternTimerOnTick;
            patternTimer.Interval = buttonLightingTime;

            Button1Command = new RelayCommand(() => game.ButtonClicked(0), () => game.ButtonsCanBeClicked);
            Button2Command = new RelayCommand(() => game.ButtonClicked(1), () => game.ButtonsCanBeClicked);
            Button3Command = new RelayCommand(() => game.ButtonClicked(2), () => game.ButtonsCanBeClicked);
            Button4Command = new RelayCommand(() => game.ButtonClicked(3), () => game.ButtonsCanBeClicked);
            StartRetryCommand = new RelayCommand(() => StartNewPattern(game.GetNewPattern()), () => true);

            Button1BackColor = new SolidColorBrush(Colors.Black);
            Button2BackColor = new SolidColorBrush(Colors.Black);
            Button3BackColor = new SolidColorBrush(Colors.Black);
            Button4BackColor = new SolidColorBrush(Colors.Black);
            StartRetryText = "Start";
            SetNumberButtonsToDefault();
        }

 protected WorkshopViewModelBase()
 {
     if (IsInDesignModeStatic)
     {
         Head = "X:123, Y:456, Z:7890";
         Neck = "X:123, Y:456, Z:7890";
         LeftShoulder = "X:123, Y:456, Z:7890";
         RightShoulder = "X:123, Y:456, Z:7890";
         Torso = "X:123, Y:456, Z:7890";
         LeftElbow = "X:123, Y:456, Z:7890";
         RightElbow = "X:123, Y:456, Z:7890";
         LeftHand = "X:123, Y:456, Z:7890";
         RightHand = "X:123, Y:456, Z:7890";
         LeftHand = "X:123, Y:456, Z:7890";
         RightHand = "X:123, Y:456, Z:7890";
         LeftHip = "X:123, Y:456, Z:7890";
         RightHip = "X:123, Y:456, Z:7890";
         LeftKnee = "X:123, Y:456, Z:7890";
         RightKnee = "X:123, Y:456, Z:7890";
         LeftFoot = "X:123, Y:456, Z:7890";
         RightFoot = "X:123, Y:456, Z:7890";
     }
     else
     {
         Kinect = MyKinect.Instance;
         PointerColor = new SolidColorBrush(Color.FromRgb(139, 0, 0));
         Messages = new ObservableCollection<string>();
         Start = new RelayCommand<RoutedEventArgs>(e => SafeStartKinect());
         Stop = new RelayCommand<RoutedEventArgs>(e => SafeStopKinect());
     }
 }

        public PostcardViewModel(string name, IEnumerable<XElement> xmlRectangles)
        {
            Name = name;
            PictureFrames = xmlRectangles.Select(r => new PictureFrameViewModel(r)).ToList();

            SelectToggleCommand = new RelayCommand(() => Selected = !Selected);
        }

        public ViewViewModel()
        {
            chatService = ServiceLocator.Current.GetInstance<IChatService>();
            parentViewModel = ServiceLocator.Current.GetInstance<PhotosViewModel>();
            timer = new Timer(new TimerCallback((c) => {
                DispatcherHelper.CheckBeginInvokeOnUI(() =>
                {
                    App.RootFrame.Navigate(new Uri("/View/PhotosPage.xaml", UriKind.RelativeOrAbsolute));
                });
            }),
            null,
            Timeout.Infinite,
            Timeout.Infinite);

            HideCommand = new RelayCommand(async () =>

            {
                timer.Change(TimeSpan.FromSeconds(6), TimeSpan.FromMilliseconds(-1));
                var contentList = await chatService.ReadPhotoContentAsync(
                    parentViewModel.SelectedPhoto.PhotoContentSecretId);
                var content = contentList.FirstOrDefault();
                if (content != null)
                {
                    Uri = chatService.ReadPhotoAsUri(content.Uri);
                    Stream = chatService.ReadPhotoAsStream(content.Uri);
                }
                else
                {
                    Uri = null;
                    Stream = null;
                }

            });
        }

        public MainViewModel()
        {
            timer = new Timer();
            service = new LMService.LMServiceClient();
            timer.Interval = 2000;
            timer.Elapsed += timer_Elapsed;

            MyTeam = new TeamViewModel();
            EnemyTeam = new TeamViewModel();
            SendSetupCommand = new RelayCommand(SendSetup);
            NewGameCommannd = new RelayCommand(NewGame);
            CanSendSetup = true;
            //Deze halen we later op vanuit de server
            Champions = new List<string>(){
              "Shaco",
              "Sona",
              "Vayne",
              "Leblanc",
              "Aatrox"
            };

            //Default setup
            MyTeam.Top = "Aatrox";
            MyTeam.Jungle = "Shaco";
            MyTeam.Mid = "Leblanc";
            MyTeam.Adc = "Vayne";
            MyTeam.Supp = "Sona";
        }

 public AddOrganizationViewModel()
 {
     DoneCommand = new RelayCommand(() =>
     {
         AddEntry();
     });
 }

        public ReplyViewModel(IBaconProvider baconProvider, Thing replyTargetThing, RelayCommand cancel, Action<Thing> convertIntoUIReply, bool isEdit = false)
        {
            _convertIntoUIReply = convertIntoUIReply;
            _cancel = cancel;
            _baconProvider = baconProvider;
            _redditService = _baconProvider.GetService<IRedditService>();
            _userService = _baconProvider.GetService<IUserService>();
            _markdownProcessor = _baconProvider.GetService<IMarkdownProcessor>();
            _replyTargetThing = replyTargetThing;

            if (isEdit)
            {
                Editing = true;
                EditingId = ((Comment)_replyTargetThing.Data).Name;
                ReplyBody = ((Comment)_replyTargetThing.Data).Body.Replace("&gt;", ">").Replace("&lt;", "<");
            }

			RefreshUserImpl();

            _addBold = new RelayCommand(AddBoldImpl);
            _addItalic = new RelayCommand(AddItalicImpl);
            _addStrike = new RelayCommand(AddStrikeImpl);
            _addSuper = new RelayCommand(AddSuperImpl);
            _addLink = new RelayCommand(AddLinkImpl);
            _addQuote = new RelayCommand(AddQuoteImpl);
            _addCode = new RelayCommand(AddCodeImpl);
            _addBullets = new RelayCommand(AddBulletsImpl);
            _addNumbers = new RelayCommand(AddNumbersImpl);
            _submit = new RelayCommand(SubmitImpl);
			_refreshUser = new RelayCommand(RefreshUserImpl);
        }

        public UnshelveDetailsServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, ProjectCollectionServiceModel projectCollectionServiceModel, WorkspaceServiceModel workspaceServiceModel, UnshelveServiceModel unshelveServiceModel, Shelveset shelveset)
            : base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
        {
            ProjectCollectionServiceModel = projectCollectionServiceModel;
            WorkspaceServiceModel = workspaceServiceModel;
            UnshelveServiceModel = unshelveServiceModel;
            Shelveset = shelveset;

            PendingChanges = new ObservableCollection<PendingChangeModel>();

            CancelCommand = new RelayCommand(Cancel, CanCancel);
            UnshelveCommand = new RelayCommand(Unshelve, CanUnshelve);

            SelectPendingChangesCommand = new RelayCommand<SelectPendingChangesCommandArgument>(SelectPendingChanges, CanSelectPendingChanges);
            SelectWorkItemsCommand = new RelayCommand<SelectWorkItemsCommandArgument>(SelectWorkItems, CanSelectWorkItems);

            PendingSet[] pendingSets;
            if (teamPilgrimServiceModelProvider.TryWorkspaceQueryShelvedChanges(WorkspaceServiceModel.Workspace, out pendingSets, shelveset.Name, shelveset.OwnerName, null))
            {
                PendingSet = pendingSets.First();

                foreach (var pendingChange in PendingSet.PendingChanges)
                {
                    PendingChanges.Add(new PendingChangeModel(pendingChange) { IncludeChange = true });
                }
            }

            PopulateSelectedPendingChangesSummary();
        }

 public ClickToChangePictureViewModel()
 {
     _myImage1 = new BitmapImage(new Uri("ms-appx:///Images/110Banana.png"));
     _myImage2 = new BitmapImage(new Uri("ms-appx:///Images/110Lemon.png"));
     ClickCommand = new RelayCommand(ChangeIamges);
     ChangeIamges();
 }

 public CheckInPageViewModel()
 {
     CheckInCommand = new RelayCommand<int>(CheckIn);
     BackCommand = new RelayCommand(NavBack);
     //GetUsersName();
     Rooms = GetRooms();
 }

        public PlayerViewModel(
            AudioPlayerHelper helper,
            ICollectionService service,
            IAppSettingsHelper appSettingsHelper)
        {
            _helper = helper;
            _service = service;
            _appSettingsHelper = appSettingsHelper;

            if (!IsInDesignMode)
            {
                helper.TrackChanged += HelperOnTrackChanged;
                helper.PlaybackStateChanged += HelperOnPlaybackStateChanged;
                helper.Shutdown += HelperOnShutdown;

                _nextRelayCommand = new RelayCommand(NextSong);
                _prevRelayCommand = new RelayCommand(PrevSong);
                _playPauseRelayCommand = new RelayCommand(PlayPauseToggle);

                _timer = new DispatcherTimer {Interval = TimeSpan.FromSeconds(1)};
                _timer.Tick += TimerOnTick;
            }
            else
            {
                CurrentQueue = service.PlaybackQueue.FirstOrDefault();
                PlayPauseIcon = Symbol.Play;
            }
        }

 public ViewStockistPurchaseOrderViewModel()
 {
     EditOrderCommand = new RelayCommand(EditOrder);
     ApproveOrderCommand = new RelayCommand(ApproveOrder);
     ViewOrderPageLoadedCommand = new RelayCommand(LoadOrder);
     CancelCommand = new RelayCommand(Cancel);
 }

        public PandocTaskViewModel()
        {
            Model = new PandocTask();

            AddTargetFile = new RelayCommand(() =>
                {
                    Model.TargetFiles.Add(new TargetFile());
                });

            RemoveTargetFile = new RelayCommand<TargetFile>(file =>
                {
                    Model.TargetFiles.Remove(file);
                }, file => file != null);

            Do = new RelayCommand(() =>
                {
                    IsBusy = true;
                    Task.Factory.StartNew(() =>
                        {
                            Result = PandocRunner.Run(this.GetLocator().Config.Model.PandocExePath, Model).Last();
                        }).ContinueWith(task =>
                            {
                                IsBusy = false;
                            });
                }, () => !IsBusy);
        }

 public StockistPurchaseOrderListingViewModel()
 {
     ViewSelectedOrderCommand = new RelayCommand<OrderItemSummary>(ViewSelectedOrder);
     CreateOrderCommand = new RelayCommand(CreateOrder);
     ViewPrintableOrderCommand = new RelayCommand<OrderItemSummary>(ViewPrintableOrder);
     ProcessOrderCommand = new RelayCommand<OrderItemSummary>(ProcessOrder);
 }

        public SupplementaryReportViewModel(IWorkListDataSource dataSource, string siteID, string accessionNumber, string caseURN, CaseConsultationList consultationList,
											bool isGlobalReadOnly = false, ReadingSiteType siteType = ReadingSiteType.interpretation)
        {
            this.DataSource = dataSource;

            // case info
            this.SiteID = siteID;
            this.AccessionNumber = accessionNumber;
            this.CaseURN = caseURN;
            this.ConsultationList = consultationList;
            this.CurrentSiteType = siteType;
            this.IsEditorReadOnly = isGlobalReadOnly;

            GetConsultationID();

            // retrieve all the supplementary reports for the case
            srModel = dataSource.GetSupplementalReports(this.CaseURN);

            ClearSRCommand = new RelayCommand(ClearSR, () => this.CanClearSR);
            AddNewSRCommand = new RelayCommand(AddNewSR, () => this.CanAddNewSR);
            UpdateSRCommand = new RelayCommand(UpdateSR, () => this.CanUpdateSR);
            VerifySRCommand = new RelayCommand(VerifySR, () => this.CanVerifySR);
            CompleteConsultationCommand = new RelayCommand(CompleteConsultation, () => this.CanCompleteConsultation);

            ClearSR();

            // retrieve the Esignature status at the case's primary site
            GetESignatureStatus();
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public LogonViewModel()
        {
            LogonCommand = new RelayCommand(LogonCommandCF, CanLogonCommand);

            // Registe MVVM Message Sytem
            Messenger.Default.Register<String>(this, MVVMMessageFunction);
        }

        /// <summary>
        /// Constructor of the class. Sets up commands and initializes variables.
        /// </summary>
        public NewMeasurementViewModel()
        {
            Database = MyGlobals.Database;

            NewSampleCommand = new RelayCommand(() => _NewSampleCommand(), () => true);

            StartMeasurementCommand = new RelayCommand(() => _StartMeasurementCommand(), () => true);
            CancelCommand = new RelayCommand(() => _CancelCommand(), () => true);

            Channels_10 = new ObservableCollection<CheckedListItem<int>> { new CheckedListItem<int>(0), new CheckedListItem<int>(1), new CheckedListItem<int>(2), new CheckedListItem<int>(3) };
            Channels_30 = new ObservableCollection<CheckedListItem<int>> { new CheckedListItem<int>(4), new CheckedListItem<int>(5) };

            Channels_10[0].IsChecked = true;
            Channels_30[0].IsChecked = true;

            Orientations = new ObservableCollection<string> { "(undefined)", "random", "aligned" };
            Chambers = new ObservableCollection<string> { "(undefined)", "-10°", "-30°" };
            StopTypes = new ObservableCollection<string> { "Manual", "Duration (min)", "Charge (µC)", "Counts", "ChopperCounts" };
            Ions = new ObservableCollection<Isotope>(Database.Elements.Where(x => x.AtomicNumber <= 3).SelectMany(y => y.Isotopes).Where(z => z.MassNumber > 0).ToList());

            Samples = new ObservableCollection<Sample>(Database.Samples.ToList());

            NewMeasurement = Database.Measurements.Where(y => y.MeasurementName != "TestMeasurement").OrderByDescending(x => x.StartTime).First();

            VariableParameters = new ObservableCollection<string> { "x", "y", "Theta", "Phi", "Energy", "Charge" };
        }

      public UpdateInstallPrompt(Version current, Version latest, bool isStable)
      {
         InitializeComponent();

         CurrentVersion = current;
         LatestVersion = latest;
         StableVersionNoticeVisibility = isStable ? Visibility.Visible : Visibility.Collapsed;
         PrereleaseVersionNoticeVisibility = isStable ? Visibility.Collapsed : Visibility.Visible;

         InstallOnExitCommand = new RelayCommand(() =>
         {
            Result = UpdatePromptResult.InstallOnExit;
            Close();
         });
         CloseAndInstallCommand = new RelayCommand(() =>
         {
            Result = UpdatePromptResult.ExitAndInstall;
            Close();
         });
         ManualInstallCommand = new RelayCommand(() =>
         {
            Result = UpdatePromptResult.InstallManually;
            Close();
         });
         CancelCommand = new RelayCommand(() =>
         {
            Result = UpdatePromptResult.None;
            Close();
         });

         Result = UpdatePromptResult.None;

         DataContext = this;
      }

        public VoucherListViewModel()
        {
            CleanAndPostVouchersCommand = new RelayCommand(CleanVouchersStub, CanRunBackgroundCleaner);

            Messenger.Default.Register<NotificationMessage<vwPayment>>(this, message =>
            {
                if (message.Notification == Notifications.HistoryPaymentSent)
                {
                    PopulateSelectedVoucherFromOldPayment(message.Content);
                }
            });
            Messenger.Default.Register<NotificationMessage<VoucherWrappersMessage>>(this, message =>
            {
                if (message.Notification == Notifications.VouchersDataCleaned)
                {
                    VoucherImports =
                        new ObservableCollection<VoucherImportWrapper>(
                            message.Content.VoucherImports.OrderBy(x => x.OkMailingAddress)
                                .ThenBy(x => x.OkPhone)
                                .ThenBy(x => x.OkEmailAddress)
                               .ToList());
                           FilterVoucherImports();
                    ExcelFileInfo = message.Content.ExcelFileInfo;
                }
                });

            Messenger.Default.Register<NotificationMessage<DataCleanCriteria>>(this, message =>
            {
                if (message.Notification == Notifications.DataCleanCriteriaUpdated)
                {
                    _dataCleanCriteria = message.Content;
                }
            });
            
        }

        public MainViewModel(INavigationService navigationService)
        {
            if (navigationService == null) throw new ArgumentNullException(nameof(navigationService));
            _navigationService = navigationService;

            ShowMessageCommand = new RelayCommand(ShowMessage);
        }