/// <summary> /// Creates a window in non-modal state. If a window with the specified viewModelType exists, the window is activated instead of being created. /// </summary> /// <param name="uiVisualizerService">The UI visualizer service.</param> /// <typeparam name="TViewModel">The type of the view model.</typeparam> /// <param name="model">The model to be injected into the view model, can be <c>null</c>.</param> /// <param name="completedProc">The completed proc. Not applicable if window already exists.</param> /// <returns><c>true</c> if shown or activated successfully, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">The <paramref name="uiVisualizerService" /> is <c>null</c>.</exception> public static Task <bool?> ShowOrActivateAsync <TViewModel>(this IUIVisualizerService uiVisualizerService, object model = null, EventHandler <UICompletedEventArgs> completedProc = null) where TViewModel : IViewModel { Argument.IsNotNull("uiVisualizerService", uiVisualizerService); var dependencyResolver = uiVisualizerService.GetDependencyResolver(); var viewModelManager = dependencyResolver.Resolve <IViewModelManager>(); var viewModel = viewModelManager.GetFirstOrDefaultInstance(typeof(TViewModel)); if (viewModel == null) { var viewModelFactory = GetViewModelFactory(uiVisualizerService); var vm = viewModelFactory.CreateViewModel(typeof(TViewModel), model); return(uiVisualizerService.ShowAsync(vm, completedProc)); } var viewLocator = dependencyResolver.Resolve <IViewLocator>(); var viewType = viewLocator.ResolveView(viewModel.GetType()); var viewManager = dependencyResolver.Resolve <IViewManager>(); var view = viewManager.GetFirstOrDefaultInstance(viewType); var window = view as System.Windows.Window; if (view == null || window == null) { return(uiVisualizerService.ShowAsync(viewModel, completedProc)); } var activated = ActivateWindow(window); return(TaskHelper <bool?> .FromResult(activated)); }
/// <summary> /// Shows a window that is registered with the specified view model in a non-modal state. /// </summary> /// <param name="this">The <see cref="IUIVisualizerService" /> service self instance.</param> /// <param name="viewModel">The view model.</param> /// <param name="openedProc">The callback procedure that will be invoked when the window is opened (registered in the <see cref="IViewManager" />). This value can be <c>null</c>.</param> /// <param name="completedProc">The callback procedure that will be invoked as soon as the window is closed. This value can be <c>null</c>.</param> /// <param name="timeOutInMilliseconds">The time out in milliseconds.</param> /// <returns><c>true</c> if the popup window is successfully opened; otherwise <c>false</c>.</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="this" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception> /// <exception cref="ViewModelNotRegisteredException">The <paramref name="viewModel" /> is not registered by the /// <see cref="IUIVisualizerService.Register(string,System.Type,bool)" /> /// method first.</exception> /// <remarks>If the <see cref="IViewManager.GetViewsOfViewModel" /> method returns no active views for the <paramref name="viewModel" /> in the expected <paramref name="timeOutInMilliseconds" /> time /// then this method will assume that the view is actually opened and invokes <paramref name="openedProc" /> anyway.</remarks> public static Task <bool?> ShowAsync(this IUIVisualizerService @this, IViewModel viewModel, Action openedProc = null, EventHandler <UICompletedEventArgs> completedProc = null, uint timeOutInMilliseconds = 10000) { Argument.IsNotNull("@this", @this); return(new Task <bool?>(() => { var innerTask = @this.ShowAsync(viewModel, completedProc); return innerTask.ContinueWith(t => { if ((t.Result ?? false) && openedProc != null) { var startTime = DateTime.Now; ThreadPool.QueueUserWorkItem(state => { var viewManager = ResolveTypeFromContainer <IViewManager>(); while (viewManager.GetViewsOfViewModel(viewModel).Length == 0 && DateTime.Now.Subtract(startTime).TotalMilliseconds < timeOutInMilliseconds) { ThreadHelper.Sleep(100); } var dispatcherService = ResolveTypeFromContainer <IDispatcherService>(); dispatcherService.Invoke(openedProc, true); }); } return t.Result; }).Result; })); }
protected override void OnOpen(object parameter = null) { _findReplaceViewModel = new FindReplaceViewModel(_findReplaceSettings, _findReplaceService); _uiVisualizerService.ShowAsync(_findReplaceViewModel); _findReplaceViewModel.ClosedAsync += OnClosedAsync; }
protected override void OnOpen() { _findReplaceViewModel = new FindReplaceViewModel(_findReplaceSerivce, CsvTextEditorService); _uiVisualizerService.ShowAsync(_findReplaceViewModel); _findReplaceViewModel.ClosedAsync += OnClosedAsync; }
/// <summary> /// Shows the window in non-modal state and creates the view model automatically using the specified model. /// </summary> /// <typeparam name="TViewModel">The type of the view model.</typeparam> /// <param name="uiVisualizerService">The UI visualizer service.</param> /// <param name="model">The model to be injected into the view model, can be <c>null</c>.</param> /// <param name="completedProc">The completed proc.</param> /// <returns><c>true</c> if shown successfully, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">The <paramref name="uiVisualizerService" /> is <c>null</c>.</exception> public static Task <bool?> ShowAsync <TViewModel>(this IUIVisualizerService uiVisualizerService, object model = null, EventHandler <UICompletedEventArgs> completedProc = null) where TViewModel : IViewModel { Argument.IsNotNull("uiVisualizerService", uiVisualizerService); var viewModelFactory = GetViewModelFactory(uiVisualizerService); var vm = viewModelFactory.CreateViewModel(typeof(TViewModel), model); return(uiVisualizerService.ShowAsync(vm, completedProc)); }
private static Task OnPropertiesCommandExecute(HeaderCommandParameter parameter) { var managePropertiesModel = new ManagePropertiesModel(); managePropertiesModel.Grid = parameter.Grid; managePropertiesModel.SelectedColumn = parameter.Column;// parameter.Grid.Selection != null ? parameter.Grid.Columns[parameter.ColumnClicked].Header : null; var viewModel = ViewModelFactory.CreateViewModel <ManagePropertiesViewModel>(managePropertiesModel, null); return(UIVisualizerService.ShowAsync(viewModel, OnPropertiesCommandCompleted)); }
protected override void OnOpen(object parameter = null) { Parameter = parameter; WindowViewModel = InitializeViewModel(); WindowViewModel.ClosedAsync += OnClosedAsync; ApplyParameter(parameter); if (IsModal) { _uiVisualizerService.ShowDialogAsync(WindowViewModel, OnWindowCompleted); } else { _uiVisualizerService.ShowAsync(WindowViewModel, OnWindowCompleted); } }
/// <summary> /// Creates a window in non-modal state. If a window with the specified viewModelType exists, the window is activated instead of being created. /// </summary> /// <typeparam name="TViewModel">The view model type.</typeparam> /// <param name="uiVisualizerService">The uiVisualizerService</param> /// <param name="dataContext">The data context.</param> /// <param name="scope">The scope.</param> /// <returns> /// A task. /// </returns> public static async Task ShowOrActivateAsync <TViewModel>(this IUIVisualizerService uiVisualizerService, object dataContext = null, object scope = null) where TViewModel : IViewModel { var dependencyResolver = uiVisualizerService.GetDependencyResolver(); var viewModelManager = dependencyResolver.Resolve <IViewModelManager>(); var viewModelFactory = dependencyResolver.Resolve <IViewModelFactory>(); var existingViewModel = viewModelManager.GetFirstOrDefaultInstance <TViewModel>(); if (existingViewModel != null) { await uiVisualizerService.ShowOrActivateAsync <TViewModel>(dataContext, scope); } else { var vm = viewModelFactory.CreateViewModel(typeof(TViewModel), dataContext, scope); await uiVisualizerService.ShowAsync(vm); } }
private async void OpenChat(ChatViewModel chat) { try { Logger.Info($"Gonna open chat '{chat.Chat.UserInfo.Name}'"); var restoreViewMessage = RestoreExistingViewMessage.Create(chat); MessageMediator.Default.SendMessage(restoreViewMessage); if (restoreViewMessage.Restored) { return; } await _visualizer.ShowAsync(chat); } catch (Exception ex) { ProcessException(ex); } }
protected override async void Execute(object parameter) { try { var location = parameter as string; var viewModel = _serviceLocator.ResolveType <ProjectWizardViewModel>(); var r = await _uIVisualizerService.ShowAsync(viewModel, (sender, args) => { if (args.DataContext is not ProjectWizardViewModel res) { return; } var result = args.Result; if (!result.HasValue || !result.Value) { return; } location = Path.Combine(res.ProjectPath, res.ProjectName); var type = res.ProjectType.First(); if (type.Equals(ProjectWizardViewModel.WitcherGameName)) { location += ".w3modproj"; } else if (type.Equals(ProjectWizardViewModel.CyberpunkGameName)) { location += ".cpmodproj"; } }); if (string.IsNullOrWhiteSpace(location)) { return; } RibbonViewModel.GlobalRibbonVM.StartScreenShown = false; RibbonViewModel.GlobalRibbonVM.BackstageIsOpen = false; using (_pleaseWaitService.PushInScope()) { switch (Path.GetExtension(location)) { case ".w3modproj": { var np = new Tw3Project(location) { Name = Path.GetFileNameWithoutExtension(location), Author = "WolvenKit", Email = "", Version = "1.0" }; _projectManager.ActiveProject = np; await _projectManager.SaveAsync(); np.CreateDefaultDirectories(); //saveProjectImg(location); break; } case ".cpmodproj": { var np = new Cp77Project(location) { Name = Path.GetFileNameWithoutExtension(location), Author = "WolvenKit", Email = "", Version = "1.0" }; _projectManager.ActiveProject = np; await _projectManager.SaveAsync(); np.CreateDefaultDirectories(); //saveProjectImg(location); break; } default: _loggerService.LogString("Invalid project path!", Logtype.Error); break; } } await _projectManager.LoadAsync(location); switch (Path.GetExtension(location)) { case ".w3modproj": await _tw3Controller.HandleStartup().ContinueWith(t => { _notificationService.Success( "Project " + Path.GetFileNameWithoutExtension(location) + " loaded!"); }, TaskContinuationOptions.OnlyOnRanToCompletion); break; case ".cpmodproj": await _cp77Controller.HandleStartup().ContinueWith( t => { _notificationService.Success("Project " + Path.GetFileNameWithoutExtension(location) + " loaded!"); }, TaskContinuationOptions.OnlyOnRanToCompletion); break; default: break; } }
public static async Task <bool?> GetFromPrompt(IUIVisualizerService _uiVisualizerService, ViewModelBase viewModel) { var result = await _uiVisualizerService.ShowAsync(viewModel, DocumentAdded) ?? false; return(result); }
private async Task OnOpenCustomerWindowCommandExecuteAsync() { var typeFactory = this.GetTypeFactory(); var customerViewModel = typeFactory.CreateInstanceWithParametersAndAutoCompletion <CustomerWindowViewModel>(); await _uiVisualizerService.ShowAsync(customerViewModel); }
private async Task OnShowViewExecuteAsync() { //TODO remake it to 1 window 2 usercontrols await _uiVisualizerService.ShowAsync <FavoritesViewModel>(); }
private void OnOpenStudents() { PersonViewModel studentsVM = new PersonViewModel(PersonType.Student); uiVisualizerService.ShowAsync(studentsVM); }
private async Task OnShowLogWindowExecuteAsync() { #pragma warning disable 4014 _uiVisualizerService.ShowAsync <LogWindowViewModel>(); #pragma warning restore 4014 }