internal static void NavigateFromImportImagesToFinish(IApplicationController controller)
 {
     Assert.IsTrue(controller.IsOnImportImagesScreen);
     Assert.IsTrue(controller.CanNext());
     controller.Next();
     Assert.IsTrue(controller.IsOnSelectDriveScreen);
 }

        public MainWindowViewModel(IApplicationController applicationController, INavigationService navigationService, IDataTransferModel transferModel)
        {
            Guard.NotNull("navigationService", navigationService);

            NavigationService = navigationService;
            NavigationActions = new NavigationActionsViewModel(applicationController, navigationService, transferModel);
        }

        public ProfileViewModel(IApplicationController app)
            : base()
        {
            _app = app;
            uModule = new UserModule();
            filterList = new ObservableCollection<gymnast>();

            // Set the menu
            MenuViewModel menuViewModel = new MenuViewModel(_app);
            menuViewModel.VisibilityLaser = false;
            Menu = menuViewModel;

            // Get the user profile
            FilterField = "";
            gymnastList = uModule.getGymnastCollection();
            applyFilter();

            //Other misc stuff
            PictureCommandVisible = Visibility.Hidden;
            EnableFilter = true;
            inEditingMode = false;
            creatingNewGymnast = false;

            setValidationRules();
        }

 internal static void NavigateFromImportImagesToSelectImages(IApplicationController controller)
 {
     Assert.IsTrue(controller.IsOnImportImagesScreen);
     Assert.IsTrue(controller.CanBack());
     controller.Back();
     Assert.IsTrue(controller.IsOnSelectImagesScreen);
 }

        public ConfigPresenter(IApplicationController applicationController, IConfigForm form)
        {
            this.applicationController = applicationController;
            this.form = form;

            manager = new ConfigManager();
        }

        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            #if (DEBUG != true)
            // Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
            // jump into the code when an exception occurs.
            DispatcherUnhandledException += AppDispatcherUnhandledException;
            AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
            #endif
            XmlConfigurator.Configure();
            _log.Debug("OnStartup called");

            var catalog = new AggregateCatalog();
            catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
            catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
            catalog.Catalogs.Add(new AssemblyCatalog(typeof(IApplicationController).Assembly));
            catalog.Catalogs.Add(new AssemblyCatalog(typeof(ValidationModel).Assembly));

            _container = new CompositionContainer(catalog);
            var batch = new CompositionBatch();
            batch.AddExportedValue(_container);
            _container.Compose(batch);

            _controller = _container.GetExportedValue<IApplicationController>();
            _controller.Initialize();
            _controller.Run();
        }

 public VaultNumberEditorViewModel(IApplicationController app)
     : base()
 {
     _app = app;
     vaultnumberModule = new EditorModule();
     Vaults = vaultnumberModule.readVaultnumbers();
 }

 public LogInViewModel(IApplicationController app)
 {
     _app = app;
     this._ShowMainWindow = new RelayCommand(ShowMainWindow);
     this._WachtwoordVergeten = new RelayCommand(ShowWachtwoordView);
     _database = ModelFactory.Database;
 }

 public MainView(IApplicationController applicationController)
 {
     InitializeComponent();
     try
     {
         _applicationController = applicationController;
         _applicationController.Subscribe<ShowViewMessage>(this, OnShowView);
         _applicationController.Subscribe<ActivateViewMessage>(this, OnActivateView);
         _applicationController.Subscribe<StartPageShownMessage>(this, OnStartPageShown);
         _applicationController.Subscribe<StartPageHiddenMessage>(this, OnStartPageHidden);
         _applicationController.Subscribe<AlertsShownMessage>(this, OnAlertsShown);
         _applicationController.Subscribe<AlertsHiddenMessage>(this, OnAlertsHidden);
         _applicationController.Subscribe<DashboardShownMessage>(this, OnDashboardShown);
         _applicationController.Subscribe<DashboardHiddenMessage>(this, OnDashboardHidden);
         _applicationController.Subscribe<EditLoanMessage>(this, OnEditLoan);
         _applicationController.Subscribe<EditSavingMessage>(this, OnEditSaving);
         _applicationController.Subscribe<RestartApplicationMessage>(this, m =>
         {
             RestartApplication(m.Language);
         });
         SetUp();
         MefContainer.Current.Bind(this);
         _menuItems = new List<MenuObject>();
         _menuItems = Services.GetMenuItemServices().GetMenuList(OSecurityObjectTypes.MenuItem);
         LoadReports();
         LoadReportsToolStrip();
         InitializeTracer();
         DisplayWinFormDetails();
         InitMenu();
     }
     catch (Exception error)
     {
         MessageBox.Show(error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }

 public LocationEditorViewModel(IApplicationController app)
     : base()
 {
     _app = app;
     locationModule = new EditorModule();
     Locations = locationModule.readLocations();
 }

 public GebruikerAccountViewModel(IApplicationController app)
 {
     _app = app;
     _opslaanCommand = new RelayCommand(Opslaan);
     _terugCommand = new RelayCommand(Terug);
     _database = ModelFactory.Database;
 }

 public VaultKindEditorViewModel(IApplicationController app)
     : base()
 {
     _app = app;
     vaultKindModule = new EditorModule();
     Vaults = vaultKindModule.readVaultKinds();
 }

 public CorporateUserControl(Corporate corporate, Form pMdiParent, IApplicationController applicationController)
 {
     _applicationController = applicationController;
     _mdifrom = pMdiParent;
        _corporate = corporate;
     _fundingLine = null;
     InitializeComponent();
     InitializeUserControlsAddress();
     InitializeCorporate();
     PicturesServices ps = ServicesProvider.GetInstance().GetPicturesServices();
     if (ps.IsEnabled())
     {
         pictureBox1.Image = ps.GetPicture("CORPORATE", corporate.Id, true, 0);
         pictureBox1.SizeMode = PictureBoxSizeMode.Zoom;
         pictureBox2.Image = ps.GetPicture("CORPORATE", corporate.Id, true, 1);
         pictureBox2.SizeMode = PictureBoxSizeMode.Zoom;
     }
     else
     {
         pictureBox1.Visible = false;
         pictureBox2.Visible = false;
         linkLabelChangePhoto.Visible = false;
         linkLabelChangePhoto2.Visible = false;
     }
 }

        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            #if (DEBUG != true)
            // Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
            // jump into the code when an exception occurs.
            DispatcherUnhandledException += AppDispatcherUnhandledException;
            AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
            #endif

            AggregateCatalog catalog = new AggregateCatalog();
            // Add the WpfApplicationFramework assembly to the catalog
            catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
            // Add the Waf.BookLibrary.Library.Presentation assembly to the catalog
            catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
            // Add the Waf.BookLibrary.Library.Applications assembly to the catalog
            catalog.Catalogs.Add(new AssemblyCatalog(typeof(ShellViewModel).Assembly));

            this.container = new CompositionContainer(catalog);
            CompositionBatch batch = new CompositionBatch();
            batch.AddExportedValue(container);
            this.container.Compose(batch);

            this.applicationController = container.GetExportedValue<IApplicationController>();
            this.applicationController.Initialize();
            this.applicationController.Run();
        }

        public VaultSelectorViewModel(IApplicationController app)
            : base()
        {
            _app = app;

            // Set menu
            MenuViewModel menuViewModel = new MenuViewModel(_app);
            menuViewModel.VisibilityLaser = false;
            Menu = menuViewModel;

            ratingVM = new RatingViewModel(_app);
            RatingControl = ratingVM;

            // get all info on startup of this viewmodel
            List<location> locations = vaultModule.getLocations();
            List<vaultnumber> vaultnumbers = vaultModule.getVaultNumbers();
            locationList = new ObservableCollection<location>(locations);
            vaultNumberList = new ObservableCollection<vaultnumber>(vaultnumbers);

            gymnastList = userModule.getGymnastCollection();

            modifyVaultVM = new ModifyVaultViewModel(_app, "SELECT", gymnastList, vaultnumbers, vaultModule.getVaultKinds(), locations);
            ModifyViewModelControl = modifyVaultVM;
            this.Content = modifyVaultVM;
            modifyVaultVM.setData(null);

            dateVisibility = Visibility.Hidden;
            OnPropertyChanged("DateVisibility");

            FilterText = "";
            filterList = new ObservableCollection<string>();
        }

        public FormLogs(IApplicationController controller, StratumModel stratum)
            : base()
        {
            this.Controller = controller;
            InitializeComponent();
            this.KeyPreview = true;

            if (ViewController.PlatformType == PlatformType.WinCE)
            {
                this.WindowState = FormWindowState.Maximized;
                this._ceControlPanel.Visible = true;
                this.Menu = null;
                this.mainMenu1.Dispose();
                this.mainMenu1 = null;
            }
            else if (ViewController.PlatformType == PlatformType.WM)
            {
                this._sip = new Microsoft.WindowsCE.Forms.InputPanel();
                this.components.Add(_sip);
                this._dataGrid.SIP = this._sip;
            }

            this._dataGrid.CellValidating += new EditableDataGridCellValidatingEventHandler(_dataGrid_CellValidating);

            DataGridAdjuster.InitializeGrid(this._dataGrid);
            DataGridTableStyle tableStyle = DataGridAdjuster.InitializeLogColumns(stratum, _dataGrid);

            _logNumColumn = tableStyle.GridColumnStyles[CruiseDAL.Schema.LOG.LOGNUMBER] as EditableTextBoxColumn;
        }

 public StudentPersoonViewModel(IApplicationController app)
 {
     _app = app;
     _verderCommand = new RelayCommand(Verder);
     _terugCommand = new RelayCommand(Back);
     fillEducation();
 }

 internal static void NavigateFromSelectPatientToSelectImages(IApplicationController controller)
 {
     Assert.IsTrue(controller.IsOnSelectPatientScreen);
     Assert.IsTrue(controller.CanNext());
     controller.Next();
     Assert.IsTrue(controller.IsOnSelectImagesScreen);
 }

 internal static void NavigateFromSelectPatientToSelectDrive(IApplicationController controller)
 {
     Assert.IsTrue(controller.IsOnSelectPatientScreen);
     Assert.IsTrue(controller.CanBack());
     controller.Back();
     Assert.IsTrue(controller.IsOnSelectDriveScreen);
 }

 public StageBedrijfViewModel(IApplicationController app)
 {
     _app = app;
     _saveCommand = new RelayCommand(Save);
     _backCommand = new RelayCommand(Back);
     _database = ModelFactory.Database;
 }