Ejemplo n.º 1
0
        public ApplicationDeleteProjectCommandContainer(
            IRecentlyUsedItemsService recentlyUsedItemsService,
            IServiceLocator serviceLocator,
            ICommandManager commandManager,
            INavigationService navigationService,
            IProjectManager projectManager,
            ISaveFileService saveFileService,
            INotificationService notificationService,
            IUIVisualizerService uIVisualizerService,
            IViewModelFactory viewModelFactory,
            IMessageService messageService,
            ILoggerService loggerService)
            : base(AppCommands.Application.DelProject, commandManager)
        {
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => serviceLocator);
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => loggerService);
            Argument.IsNotNull(() => saveFileService);

            _recentlyUsedItemsService = recentlyUsedItemsService;
            _serviceLocator           = serviceLocator;
            _navigationService        = navigationService;
            _loggerService            = loggerService;
            _saveFileService          = saveFileService;
            _uIVisualizerService      = uIVisualizerService;
            _viewModelFactory         = viewModelFactory;
            _messageService           = messageService;
        }
Ejemplo n.º 2
0
        public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
                               ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
                               IMessageService messageService, ISelectDirectoryService selectDirectoryService, IDirectoryService directoryService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => selectDirectoryService);
            Argument.IsNotNull(() => directoryService);

            _navigationService        = navigationService;
            _uiVisualizerService      = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _processService           = processService;
            _messageService           = messageService;
            _selectDirectoryService   = selectDirectoryService;
            _directoryService         = directoryService;

            OpenProject          = new TaskCommand(OnOpenProjectExecuteAsync);
            OpenRecentlyUsedItem = new TaskCommand <string>(OnOpenRecentlyUsedItemExecuteAsync);
            OpenInExplorer       = new TaskCommand <string>(OnOpenInExplorerExecuteAsync);
            UnpinItem            = new Command <string>(OnUnpinItemExecute);
            PinItem = new Command <string>(OnPinItemExecute);

            ShowKeyboardMappings = new TaskCommand(OnShowKeyboardMappingsExecuteAsync);

            commandManager.RegisterCommand("File.Open", OpenProject, this);

            var assembly = AssemblyHelper.GetEntryAssembly();

            Title = assembly.Title();
        }
Ejemplo n.º 3
0
        public RecentlyUsedItemsProjectWatcher(IProjectManager projectManager, IRecentlyUsedItemsService recentlyUsedItemsService)
            : base(projectManager)
        {
            Argument.IsNotNull(() => recentlyUsedItemsService);

            _recentlyUsedItemsService = recentlyUsedItemsService;
        }
Ejemplo n.º 4
0
        public RecentlyUsedItemsViewModel(
            IRecentlyUsedItemsService recentlyUsedItemsService,
            IMessageService messageService,
            IProcessService processService,
            IOpenFileService openFileService)
        {
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => openFileService);

            _recentlyUsedItemsService = recentlyUsedItemsService;
            _messageService           = messageService;
            _processService           = processService;
            _openFileService          = openFileService;

            SettingsCommand  = new RelayCommand(ExecSC, CanSC);
            TutorialsCommand = new RelayCommand(ExecTC, CanTC);
            WikiCommand      = new RelayCommand(ExecWC, CanWC);

            PinItem        = new Command <string>(OnPinItemExecute);
            UnpinItem      = new Command <string>(OnUnpinItemExecute);
            OpenInExplorer = new Command <string>(OnOpenInExplorerExecute);

            recentlyUsedItemsService.Items
            .Connect()
            .ObserveOn(RxApp.MainThreadScheduler)
            .Bind(out _recentlyUsedItems)
            .Subscribe(OnRecentlyUsedItemsChanged);
        }
Ejemplo n.º 5
0
        public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
            ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
            IMessageService messageService, ISelectDirectoryService selectDirectoryService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => selectDirectoryService);

            _navigationService = navigationService;
            _uiVisualizerService = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _processService = processService;
            _messageService = messageService;
            _selectDirectoryService = selectDirectoryService;

            OpenProject = new Command(OnOpenProjectExecute);
            OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute);
            OpenInExplorer = new Command<string>(OnOpenInExplorerExecute);
            UnpinItem = new Command<string>(OnUnpinItemExecute);
            PinItem = new Command<string>(OnPinItemExecute);

            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            commandManager.RegisterCommand("File.Open", OpenProject, this);

            var assembly = AssemblyHelper.GetEntryAssembly();
            Title = assembly.Title();
        }
Ejemplo n.º 6
0
        public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
                               ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
                               IMessageService messageService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => messageService);

            _navigationService        = navigationService;
            _uiVisualizerService      = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _processService           = processService;
            _messageService           = messageService;

            OpenRecentlyUsedItem = new Command <string>(OnOpenRecentlyUsedItemExecute);
            UnpinItem            = new Command <string>(OnUnpinItemExecute);
            PinItem              = new Command <string>(OnPinItemExecute);
            OpenInExplorer       = new Command <string>(OnOpenInExplorerExecute);
            Help                 = new Command(OnHelpExecute);
            Exit                 = new Command(OnExitExecute);
            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            commandManager.RegisterCommand("Help.About", Help, this);
            commandManager.RegisterCommand("File.Exit", Exit, this);

            var assembly = AssemblyHelper.GetEntryAssembly();

            Title = assembly.Title();
        }
Ejemplo n.º 7
0
        public CommandsService(StudioStateModel model,
            ICommandManager commandManager,
            IMementoService mementoService,
            IMessageService messageService,
            IOpenFileService openFileService,
            IRecentlyUsedItemsService recentlyUsedItemsService,
            ISaveFileService saveFileService,
            IProcessService processService)
        {
            Argument.IsNotNull(() => model);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => mementoService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => saveFileService);
            Argument.IsNotNull(() => processService);

            this.model = model;
            this.commandManager = commandManager;
            this.mementoService = mementoService;
            this.messageService = messageService;
            this.openFileService = openFileService;
            this.recentlyUsedItemsService = recentlyUsedItemsService;
            this.saveFileService = saveFileService;
            this.processService = processService;

            this.UndoCommand = new Command(this.Undo, this.CanUndo);
            this.RedoCommand = new Command(this.Redo, this.CanRedo);
            this.OpenProjectCommand = new Command(this.OpenProject, () => true);

            this.SaveProjectAsCommand = new Command(delegate { this.SaveAsProject(); }, () => true);
            this.SaveProjectCommand = new Command(delegate { this.SaveProject(); }, this.CanSave);

            this.OpenRecentlyUsedItemCommand = new Command<string>(this.OnOpenRecentlyUsedItemExecute);

            this.PinItemCommand = new Command<string>(this.PinItem);
            this.UnpinItemCommand = new Command<string>(this.UnpinItem);
            this.OpenInExplorerCommand = new Command<string>(this.OpenInExplorer);

            this.StartCommand = new Command(this.Start, this.CanStart);

            this.ExitCommand = new Command(this.Exit);

            commandManager.RegisterCommand("Script.Open", this.OpenProjectCommand);
            commandManager.RegisterCommand("Script.Save", this.SaveProjectCommand);
            commandManager.RegisterCommand("Script.SaveAs", this.SaveProjectAsCommand);
            commandManager.RegisterCommand("App.Exit", this.ExitCommand);

            this.model.ProjectPropertyChanged += this.OnProjectPropertyChanged;
        }
Ejemplo n.º 8
0
        public RecentlyUsedItemsViewModel(IRecentlyUsedItemsService recentlyUsedItemsService, IFileService fileService,
                                          IMessageService messageService, IProcessService processService)
        {
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => fileService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);

            _recentlyUsedItemsService = recentlyUsedItemsService;
            _fileService    = fileService;
            _messageService = messageService;
            _processService = processService;

            PinItem        = new Command <string>(OnPinItemExecute);
            UnpinItem      = new Command <string>(OnUnpinItemExecute);
            OpenInExplorer = new Command <string>(OnOpenInExplorerExecute);
        }
Ejemplo n.º 9
0
        public ProjectManager(
            IRecentlyUsedItemsService recentlyUsedItemsService,
            INotificationService notificationService,
            ILoggerService loggerService
            )
        {
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _notificationService      = notificationService;
            _loggerService            = loggerService;

            this.WhenAnyValue(x => x.ActiveProject).Subscribe(async _ =>
            {
                if (IsProjectLoaded)
                {
                    await SaveAsync();
                }
            });
        }
Ejemplo n.º 10
0
        public RibbonViewModel(INavigationService navigationService, 
            IUIVisualizerService uiVisualizerService,
            ICommandManager commandManager, 
            IRecentlyUsedItemsService recentlyUsedItemsService, 
            IOpenFileService openFileService,
            IMessageService messageService,
            IProcessService processService,
            IFileService fileService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => fileService);

            _navigationService = navigationService;
            _uiVisualizerService = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _openFileService = openFileService;
            _messageService = messageService;
            _processService = processService;
            _fileService = fileService;

            Help = new Command(OnHelpExecute);
            Open = new Command(this.OnOpenExecute);
            Exit = new Command(OnExitExecute);
            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute);
            UnpinItem = new Command<string>(OnUnpinItemExecute);
            PinItem = new Command<string>(OnPinItemExecute);
            OpenInExplorer = new Command<string>(OnOpenInExplorerExecute);

            OnRecentlyUsedItemsServiceUpdated(null, null);

            commandManager.RegisterCommand("Help.About", Help, this);
            commandManager.RegisterCommand("File.Open", Open, this);
            commandManager.RegisterCommand("File.Exit", Exit, this);
        }
Ejemplo n.º 11
0
        public RibbonViewModel(INavigationService navigationService,
                               IUIVisualizerService uiVisualizerService,
                               ICommandManager commandManager,
                               IRecentlyUsedItemsService recentlyUsedItemsService,
                               IOpenFileService openFileService,
                               IMessageService messageService,
                               IProcessService processService,
                               IFileService fileService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => fileService);

            _navigationService        = navigationService;
            _uiVisualizerService      = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _openFileService          = openFileService;
            _messageService           = messageService;
            _processService           = processService;
            _fileService = fileService;

            Help = new TaskCommand(OnHelpExecuteAsync);
            Open = new TaskCommand(this.OnOpenExecuteAsync);
            Exit = new Command(OnExitExecute);
            ShowKeyboardMappings = new TaskCommand(OnShowKeyboardMappingsExecuteAsync);

            OpenRecentlyUsedItem = new TaskCommand <string>(OnOpenRecentlyUsedItemExecuteAsync);
            UnpinItem            = new Command <string>(OnUnpinItemExecute);
            PinItem        = new Command <string>(OnPinItemExecute);
            OpenInExplorer = new TaskCommand <string>(OnOpenInExplorerExecuteAsync);

            OnRecentlyUsedItemsServiceUpdated(null, null);

            commandManager.RegisterCommand("Help.About", Help, this);
            commandManager.RegisterCommand("File.Open", Open, this);
            commandManager.RegisterCommand("File.Exit", Exit, this);
        }
Ejemplo n.º 12
0
        public WelcomePageViewModel(
            IRecentlyUsedItemsService recentlyUsedItemsService,
            ISettingsManager settingsManager,
            IProjectManager projectManager
            )
        {
            _mainViewModel = Locator.Current.GetService <AppViewModel>();

            _projectManager           = projectManager;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _settingsManager          = settingsManager;

            CloseHomePage = new RelayCommand(ExecuteHome, CanHome);

            SettingsCommand  = new RelayCommand(ExecSC, CanSC);
            TutorialsCommand = new RelayCommand(ExecTC, CanTC);
            WikiCommand      = new RelayCommand(ExecWC, CanWC);

            PinItem        = new DelegateCommand <string>(OnPinItemExecute);
            UnpinItem      = new DelegateCommand <string>(OnUnpinItemExecute);
            OpenInExplorer = new DelegateCommand <string>(OnOpenInExplorerExecute);

            OpenProjectCommand = ReactiveCommand.Create <string>(s =>
            {
                _mainViewModel.OpenProjectCommand.Execute(s).Subscribe();
            });
            DeleteProjectCommand = ReactiveCommand.Create <string>(s =>
            {
                _mainViewModel.DeleteProjectCommand.Execute(s).Subscribe();
            });
            NewProjectCommand = ReactiveCommand.Create(() =>
            {
                _mainViewModel.NewProjectCommand.Execute().Subscribe();
            });

            recentlyUsedItemsService.Items
            .Connect()
            .ObserveOn(RxApp.MainThreadScheduler)
            .Bind(out _recentlyUsedItems)
            .Subscribe(OnRecentlyUsedItemsChanged);
        }
Ejemplo n.º 13
0
        public RecentlyUsedItemsViewModel(IRecentlyUsedItemsService recentlyUsedItemsService, IFileService fileService,
                                          IMessageService messageService, IProcessService processService)
        {
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => fileService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);

            _recentlyUsedItemsService = recentlyUsedItemsService;
            _fileService    = fileService;
            _messageService = messageService;
            _processService = processService;

            SettingsCommand  = new RelayCommand(ExecSC, CanSC);
            TutorialsCommand = new RelayCommand(ExecTC, CanTC);
            WikiCommand      = new RelayCommand(ExecWC, CanWC);

            PinItem        = new Command <string>(OnPinItemExecute);
            UnpinItem      = new Command <string>(OnUnpinItemExecute);
            OpenInExplorer = new Command <string>(OnOpenInExplorerExecute);
        }
        public ApplicationOpenProjectCommandContainer(
            ICommandManager commandManager,
            IProjectManager projectManager,
            IOpenFileService openFileService,
            IPleaseWaitService pleaseWaitService,
            INotificationService notificationService,
            IRecentlyUsedItemsService recentlyUsedItemsService,
            ILoggerService loggerService,
            Tw3Controller tw3Controller,
            Cp77Controller cp77Controller
            )
            : base(AppCommands.Application.OpenProject, commandManager, projectManager, notificationService,
                   loggerService)
        {
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => pleaseWaitService);
            Argument.IsNotNull(() => recentlyUsedItemsService);

            _pleaseWaitService        = pleaseWaitService;
            _openFileService          = openFileService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _tw3Controller            = tw3Controller;
            _cp77Controller           = cp77Controller;
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Class constructor
        /// </summary>
        public AppViewModel(
            IProjectManager projectManager,
            ILoggerService loggerService,
            IGameControllerFactory gameControllerFactory,
            IUpdateService updateService,
            ISettingsManager settingsManager,
            INotificationService notificationService,
            IRecentlyUsedItemsService recentlyUsedItemsService
            )
        {
            _updateService            = updateService;
            _projectManager           = projectManager;
            _loggerService            = loggerService;
            _gameControllerFactory    = gameControllerFactory;
            _settingsManager          = settingsManager;
            _notificationService      = notificationService;
            _recentlyUsedItemsService = recentlyUsedItemsService;

            #region commands

            ShowLogCommand             = new RelayCommand(ExecuteShowLog, CanShowLog);
            ShowProjectExplorerCommand = new RelayCommand(ExecuteShowProjectExplorer, CanShowProjectExplorer);
            //ShowImportUtilityCommand = new RelayCommand(ExecuteShowImportUtility, CanShowImportUtility);
            ShowPropertiesCommand = new RelayCommand(ExecuteShowProperties, CanShowProperties);
            ShowAssetsCommand     = new RelayCommand(ExecuteAssetBrowser, CanShowAssetBrowser);
            //ShowVisualEditorCommand = new RelayCommand(ExecuteVisualEditor, CanShowVisualEditor);
            //ShowAudioToolCommand = new RelayCommand(ExecuteAudioTool, CanShowAudioTool);
            //ShowVideoToolCommand = new RelayCommand(ExecuteVideoTool, CanShowVideoTool);
            //ShowCodeEditorCommand = new RelayCommand(ExecuteCodeEditor, CanShowCodeEditor);

            ShowImportExportToolCommand = new RelayCommand(ExecuteImportExportTool, CanShowImportExportTool);
            //ShowPackageInstallerCommand = new RelayCommand(ExecuteShowInstaller, CanShowInstaller);

            OpenFileCommand = new DelegateCommand <FileModel>(async(p) => await ExecuteOpenFile(p), CanOpenFile);

            PackModCommand = new RelayCommand(ExecutePackMod, CanPackMod);
            //BackupModCommand = new RelayCommand(ExecuteBackupMod, CanBackupMod);
            //PublishModCommand = new RelayCommand(ExecutePublishMod, CanPublishMod);

            NewFileCommand  = new DelegateCommand <string>(ExecuteNewFile, CanNewFile);
            SaveFileCommand = new RelayCommand(ExecuteSaveFile, CanSaveFile);
            SaveAllCommand  = new RelayCommand(ExecuteSaveAll, CanSaveAll);

            FileSelectedCommand = new DelegateCommand <FileModel>(async(p) => await ExecuteSelectFile(p), CanSelectFile);

            OpenProjectCommand   = ReactiveCommand.CreateFromTask <string, Unit>(OpenProjectAsync);
            DeleteProjectCommand = ReactiveCommand.Create <string>(DeleteProject);
            NewProjectCommand    = ReactiveCommand.CreateFromTask(NewProjectAsync);

            #endregion commands

            OnStartup();

            DockedViews = new ObservableCollection <IDockElement> {
                Log,
                ProjectExplorer,
                PropertiesViewModel,
                AssetBrowserVM,
                ImportExportToolVM,
            };

            _settingsManager
            .WhenAnyValue(x => x.UpdateChannel)
            .Subscribe(_ =>
            {
                _updateService.SetUpdateChannel((WolvenManager.Installer.Models.EUpdateChannel)_settingsManager.UpdateChannel);
                Task.Run(() => _updateService.CheckForUpdatesAsync());
            });
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Class constructor
        /// </summary>
        public AppViewModel(
            IProjectManager projectManager,
            ILoggerService loggerService,
            IGameControllerFactory gameControllerFactory,
            ISettingsManager settingsManager,
            INotificationService notificationService,
            IRecentlyUsedItemsService recentlyUsedItemsService,
            IProgressService <double> progressService,
            IWatcherService watcherService,
            AutoInstallerService autoInstallerService
            )
        {
            _projectManager           = projectManager;
            _loggerService            = loggerService;
            _gameControllerFactory    = gameControllerFactory;
            _settingsManager          = settingsManager;
            _notificationService      = notificationService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _progressService          = progressService;
            _watcherService           = watcherService;
            _autoInstallerService     = autoInstallerService;

            _homePageViewModel = Locator.Current.GetService <HomePageViewModel>();

            #region commands

            ShowLogCommand             = new RelayCommand(ExecuteShowLog, CanShowLog);
            ShowProjectExplorerCommand = new RelayCommand(ExecuteShowProjectExplorer, CanShowProjectExplorer);
            //ShowImportUtilityCommand = new RelayCommand(ExecuteShowImportUtility, CanShowImportUtility);
            ShowPropertiesCommand = new RelayCommand(ExecuteShowProperties, CanShowProperties);
            ShowAssetsCommand     = new RelayCommand(ExecuteAssetBrowser, CanShowAssetBrowser);
            //ShowVisualEditorCommand = new RelayCommand(ExecuteVisualEditor, CanShowVisualEditor);
            //ShowAudioToolCommand = new RelayCommand(ExecuteAudioTool, CanShowAudioTool);
            //ShowVideoToolCommand = new RelayCommand(ExecuteVideoTool, CanShowVideoTool);
            //ShowCodeEditorCommand = new RelayCommand(ExecuteCodeEditor, CanShowCodeEditor);

            ShowImportExportToolCommand = new RelayCommand(ExecuteImportExportTool, CanShowImportExportTool);
            //ShowPackageInstallerCommand = new RelayCommand(ExecuteShowInstaller, CanShowInstaller);

            ShowPluginCommand = new RelayCommand(ExecuteShowPlugin, CanShowPlugin);

            OpenFileCommand         = new DelegateCommand <FileModel>(p => ExecuteOpenFile(p), CanOpenFile);
            OpenFileAsyncCommand    = ReactiveCommand.CreateFromTask <FileModel, Unit>(OpenFileAsync);
            OpenRedFileAsyncCommand = ReactiveCommand.CreateFromTask <FileEntry, Unit>(OpenRedFileAsync);

            var canExecute = this.WhenAny(x => x._projectManager.ActiveProject, (p) => p != null);
            PackModCommand        = ReactiveCommand.CreateFromTask(ExecutePackMod, canExecute);
            PackInstallModCommand = ReactiveCommand.CreateFromTask(ExecutePackInstallMod, canExecute);
            //BackupModCommand = new RelayCommand(ExecuteBackupMod, CanBackupMod);
            //PublishModCommand = new RelayCommand(ExecutePublishMod, CanPublishMod);

            NewFileCommand  = new DelegateCommand <string>(ExecuteNewFile, CanNewFile);
            SaveFileCommand = new RelayCommand(ExecuteSaveFile, CanSaveFile);
            SaveAsCommand   = new RelayCommand(ExecuteSaveAs, CanSaveFile);
            SaveAllCommand  = new RelayCommand(ExecuteSaveAll, CanSaveAll);

            FileSelectedCommand = new DelegateCommand <FileModel>(async(p) => await ExecuteSelectFile(p), CanSelectFile);

            OpenProjectCommand   = ReactiveCommand.CreateFromTask <string, Unit>(OpenProjectAsync);
            DeleteProjectCommand = ReactiveCommand.Create <string>(DeleteProject);
            NewProjectCommand    = ReactiveCommand.Create(ExecuteNewProject);

            ShowHomePageCommand = new RelayCommand(ExecuteShowHomePage, CanShowHomePage);
            ShowSettingsCommand = new RelayCommand(ExecuteShowSettings, CanShowSettings);

            CloseModalCommand   = new RelayCommand(ExecuteCloseModal, CanCloseModal);
            CloseOverlayCommand = new RelayCommand(ExecuteCloseOverlay, CanCloseOverlay);
            CloseDialogCommand  = new RelayCommand(ExecuteCloseDialog, CanCloseDialog);


            OpenFileAsyncCommand.ThrownExceptions.Subscribe(ex => LogExtended(ex));
            OpenRedFileAsyncCommand.ThrownExceptions.Subscribe(ex => LogExtended(ex));
            PackModCommand.ThrownExceptions.Subscribe(ex => LogExtended(ex));
            PackInstallModCommand.ThrownExceptions.Subscribe(ex => LogExtended(ex));
            OpenProjectCommand.ThrownExceptions.Subscribe(ex => LogExtended(ex));

            #endregion commands

            UpdateTitle();

            if (!TryLoadingArguments())
            {
                SetActiveOverlay(_homePageViewModel);
            }

            OnStartup();

            DockedViews = new ObservableCollection <IDockElement> {
                Log,
                ProjectExplorer,
                PropertiesViewModel,
                AssetBrowserVM,
                ImportExportToolVM,
            };


            _settingsManager
            .WhenAnyValue(x => x.UpdateChannel)
            .Subscribe(async x =>
            {
                _autoInstallerService.UseChannel(x.ToString());

                // 1 API call
                if (!(await _autoInstallerService.CheckForUpdate())
                    .Out(out var release))
                {
                    return;
                }

                if (release.TagName.Equals(_settingsManager.GetVersionNumber()))
                {
                    return;
                }

                _settingsManager.IsUpdateAvailable = true;
                _loggerService.Success($"Update available: {release.TagName}");

                //var result = await Interactions.ShowMessageBoxAsync("An update is available for WolvenKit. Exit the app and install it?", "Update available");
                //switch (result)
                //{
                //    case WMessageBoxResult.OK:
                //    case WMessageBoxResult.Yes:
                //        if (await _autoInstallerService.Update()) // 1 API call
                //        {

                //        }
                //        break;
                //}
            });
        }