コード例 #1
0
        /// <summary>
        /// Method to invoke when the AddEmployee command is executed.
        /// </summary>
        private async Task OnAddEmployeeExecuteAsync()
        {
            var employee = new Employee()
            {
                Department = SelectedDepartment
            };

            var typeFactory = TypeFactory.Default;
            var viewModel   = typeFactory.CreateInstanceWithParametersAndAutoCompletion <EmployeeViewModel>(employee);

            if (!(await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false))
            {
                return;
            }

            _employeeRepository.AddEmployee(employee);

            if (employee.Department == SelectedDepartment)
            {
                Employees.Add(employee);
            }

            MessageMediator.SendMessage(employee.Department, "UpdateSelectedDepartmentFromEM");
            Mediator.SendMessage(string.Format("Employee {0} {1} is added in department {2}", employee.FirstName, employee.LastName, employee.Department.Name), "UpdateNotification");
        }
コード例 #2
0
        public Task <MessageResult> ShowAsync(string message, string caption = "", string helpLink                 = null,
                                              MessageButton button           = MessageButton.OK, MessageImage icon = MessageImage.None)
        {
            var tcs = new TaskCompletionSource <MessageResult>();

#pragma warning disable AvoidAsyncVoid
            _dispatcherService.BeginInvoke(async() =>
#pragma warning restore AvoidAsyncVoid
            {
                var previousCursor   = Mouse.OverrideCursor;
                Mouse.OverrideCursor = null;

                var vm = _viewModelFactory.CreateViewModel <HelpLinkMessageBoxViewModel>(null, null);

                vm.Message  = message;
                vm.Button   = button;
                vm.Icon     = icon;
                vm.HelpLink = helpLink;

                vm.SetTitle(caption);

                await _uiVisualizerService.ShowDialogAsync(vm);

                Mouse.OverrideCursor = previousCursor;

                tcs.TrySetResult(vm.Result);
            });

            return(tcs.Task);
        }
コード例 #3
0
 private async Task ViewModelOnSavingAsync(object sender, SavingEventArgs e)
 {
     _closingViewModel       = new ProgressWindowViewModel();
     _closingViewModel.Title = "Saving...";
     _closingViewModel.SetOwnerWindow(this);
     _visualizerService.ShowDialogAsync(_closingViewModel);
 }
コード例 #4
0
        private async Task OnNewSchemeExecuteAsync()
        {
            if (_targetType is null)
            {
                Log.Warning("Target type is unknown, cannot get any type information to create filters");
                return;
            }

            var filterScheme         = new FilterScheme(_targetType);
            var filterSchemeEditInfo = new FilterSchemeEditInfo(filterScheme, RawCollection, AllowLivePreview, EnableAutoCompletion);

            if (!(await _uiVisualizerService.ShowDialogAsync <EditFilterViewModel>(filterSchemeEditInfo) ?? false))
            {
                return;
            }

            if (_filterSchemes is null || _filterSchemeManager is null)
            {
                return;
            }

            _filterSchemes.Schemes.Add(filterScheme);

            UpdateFilterGroups();

            ApplyFilterScheme(filterScheme, true);

            await _filterSchemeManager.UpdateFiltersAsync();
        }
コード例 #5
0
        /// <summary>
        /// Method to invoke when the Help command is executed.
        /// </summary>
        private async Task OnHelpExecuteAsync()
        {
            var aboutInfo = new AboutInfo(new Uri("pack://application:,,,/Resources/Images/CompanyLogo.png", UriKind.RelativeOrAbsolute),
                                          "/Orchestra.Examples.Ribbon.Microsoft;component/Resources/Images/CompanyLogo.png",
                                          new UriInfo("http://www.catelproject.com", "Product website"));

            await _uiVisualizerService.ShowDialogAsync <AboutViewModel>(aboutInfo);
        }
コード例 #6
0
        /// <summary>
        /// Method to invoke when the Add command is executed.
        /// </summary>
        private async Task OnAddExecuteAsync()
        {
            var viewModel = new PersonViewModel(new Person());

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                PersonCollection.Add(viewModel.Person);
            }
        }
コード例 #7
0
        private async Task OnAddExecuteAsync()
        {
            var person = new Person();

            if (await _uiVisualizerService.ShowDialogAsync <PersonViewModel>(person) ?? false)
            {
                PersonCollection.Add(person);
            }
        }
コード例 #8
0
        /// <summary>
        /// Method to invoke when the Add command is executed.
        /// </summary>
        private async Task OnAddAxisExecuteAsync()
        {
            var viewModel = new AxisDefinitionViewModel(new AxisDefinitionModel());

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                Axes.Add(viewModel.AxisDefinitionModel);
                ViewModelCommandManager.InvalidateCommands(true);
            }
        }
コード例 #9
0
        /// <summary>
        /// Method to invoke when the Add command is executed.
        /// </summary>
        private async Task OnAddExecuteAsync()
        {
            var typeFactory = TypeFactory.Default;
            var viewModel   = typeFactory.CreateInstanceWithParametersAndAutoCompletion <PersonViewModel>(new Person());

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                PersonCollection.Add(viewModel.Person);
            }
        }
コード例 #10
0
        /// <summary>
        /// Method to invoke when the ShowKeyboardMappings command is executed.
        /// </summary>
        private async Task OnAddTypeCommandExecuteAsync()
        {
            var type = new Type();

            type.TypeName = "New Type";
            var viewModel = _viewModelFactory.CreateViewModel <TypeViewModel>(type);

            viewModel.Title       = "Add Type";
            viewModel.SavedAsync += ViewModelOnSavedAsync;
            await _visualizerService.ShowDialogAsync(viewModel);
        }
コード例 #11
0
        private async Task OnCreateWorkspaceExecuteAsync()
        {
            var workspace = new Workspace();

            if (await _uiVisualizerService.ShowDialogAsync <WorkspaceViewModel>(workspace) ?? false)
            {
                await _workspaceManager.AddAsync(workspace, true);

                await _workspaceManager.StoreAndSaveAsync();
            }
        }
コード例 #12
0
        private async Task OnAddCommandExecuteAsync()
        {
            var logFilter = new LogFilter();

            if (await _uiVisualizerService.ShowDialogAsync <LogFilterEditorViewModel>(logFilter) ?? false)
            {
                LogFilters.Add(logFilter);
                SelectedLogFilter = logFilter;

                Validate(true);
            }
        }
コード例 #13
0
        private async Task OnCreateEnrollmentCommandExecuteAsync()
        {
            var isCancel = await uiVisualizerService.ShowDialogAsync <EnrollmentDetailsViewModel>() ?? false;

            if (isCancel)
            {
                await UpdateDatesAsync();
                await UpdateEnrollmentsAsync();

                SelectedEnrollment = Enrollments.LastOrDefault();
            }
        }
コード例 #14
0
        private static Task OnChangeFontCommandExecute(HeaderCommandParameter parameter)
        {
            Argument.IsNotNull(() => parameter);

            var manageFontModel = new ManageFontModel {
                Grid = parameter.Grid
            };

            var viewModel = ViewModelFactory.CreateViewModel <ManageFontViewModel>(manageFontModel);

            return(UIVisualizerService.ShowDialogAsync(viewModel, OnManageFontCompleted));
        }
コード例 #15
0
        private async Task OnAddCommandExecuteAsync()
        {
            var logFilterGroup = new LogFilterGroup();

            if (await _uiVisualizerService.ShowDialogAsync <LogFilterGroupEditorViewModel>(logFilterGroup) ?? false)
            {
                FilterGroups.Add(logFilterGroup);
                await SaveFilterGroupsAsync();

                Updated.SafeInvoke(this);
            }
        }
コード例 #16
0
        private async Task OnAddCustomerCommandExecuteAsync()
        {
            var customer = new Customer();

            var typeFactory = this.GetTypeFactory();
            var viewModel   = typeFactory.CreateInstanceWithParametersAndAutoCompletion <CustomerAddWindowViewModel>(customer);

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                customer.Save();
                Customers.Add(customer);
            }
        }
コード例 #17
0
        /// <summary>
        /// Method to invoke when the AddFamily command is executed.
        /// </summary>
        private async Task OnAddFamilyExecuteAsync()
        {
            var family = new Family();
            // Note that we use the type factory here because it will automatically take care of any dependencies
            // that the FamilyWindowViewModel will add in the future
            var typeFactory           = this.GetTypeFactory();
            var familyWindowViewModel = typeFactory.CreateInstanceWithParametersAndAutoCompletion <FamilyWindowViewModel>(family);

            if (await _uiVisualizerService.ShowDialogAsync(familyWindowViewModel) ?? false)
            {
                Families.Add(family);
            }
        }
コード例 #18
0
        private async Task OnAddProductCommandExecuteAsync()
        {
            var product = new Product();

            var typeFactory = this.GetTypeFactory();
            var viewModel   = typeFactory.CreateInstanceWithParametersAndAutoCompletion <ProductAddWindowViewModel>(product);

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                product.Save();
                Products.Add(product);
            }
        }
コード例 #19
0
        /// <summary>
        /// Method to invoke when the AddPerson command is executed.
        /// </summary>
        private async Task OnAddPersonExecuteAsync()
        {
            var person = new Person();

            person.LastName = FamilyName;
            // Note that we use the type factory here because it will automatically take care of any dependencies
            // that the PersonViewModel will add in the future
            var typeFactory     = this.GetTypeFactory();
            var personViewModel = typeFactory.CreateInstanceWithParametersAndAutoCompletion <PersonViewModel>(person);

            if (await _uiVisualizerService.ShowDialogAsync(personViewModel) ?? false)
            {
                Persons.Add(person);
            }
        }
コード例 #20
0
        private async Task OnShowPackageSourceSettingsExecuteAsync()
        {
            var nugetSettingsVm = _typeFactory.CreateInstanceWithParametersAndAutoCompletion <NuGetSettingsViewModel>();

            if (nugetSettingsVm is not null)
            {
                var result = await _uIVisualizerService.ShowDialogAsync(nugetSettingsVm);

                if (result ?? false)
                {
                    //update available feeds
                    ActiveFeeds = new ObservableCollection <INuGetSource>(GetActiveFeedsFromSettings());
                }
            }
        }
コード例 #21
0
        private void OnOpenLookUpExecute()
        {
            Type tVm     = Type.GetType(TypeVM);
            var  tVMCtor = tVm.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });

            uiVisualizerService.ShowDialogAsync((IViewModel)tVMCtor, ReturnValue);
        }
コード例 #22
0
        internal async Task CheckDirectoriesAsync()
        {
            var dodgy = new List <string>();

            using (new CursorOverride(Cursors.Wait))
            {
                var files = ListFiles();
                foreach (var file in files)
                {
                    if (!legitDirectories.Contains(file.Path))
                    {
                        dodgy.Add(file.Path);
                    }
                }
            }
            if (dodgy.Count == 0)
            {
                MessageBox.Show("Nothing dodgy", "WebWriter AntiHacker", MessageBoxButton.OK, MessageBoxImage.Information);
            }
            else
            {
                IUIVisualizerService uIVisualiserService = ServiceLocator.Default.ResolveType <IUIVisualizerService>();
                if (!(uIVisualiserService is null))
                {
                    await uIVisualiserService.ShowDialogAsync <DodgyStuffViewModel>(dodgy);
                }
            }
        }
コード例 #23
0
        public override Task <MessageResult> ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
        {
            Argument.IsNotNullOrWhitespace("message", message);

            Log.Info("Showing message to the user:\n\n{0}", this.GetAsText(message, button));

            var tcs = new TaskCompletionSource <MessageResult>();

#pragma warning disable AvoidAsyncVoid
            _dispatcherService.BeginInvoke(async() =>
#pragma warning restore AvoidAsyncVoid
            {
                var previousCursor   = Mouse.OverrideCursor;
                Mouse.OverrideCursor = null;

                var vm = _viewModelFactory.CreateViewModel <MessageBoxViewModel>(null, null);

                vm.Message = message;
                vm.Button  = button;
                vm.Icon    = icon;

                vm.SetTitle(caption);

                await _uiVisualizerService.ShowDialogAsync(vm);

                Mouse.OverrideCursor = previousCursor;

                Log.Info("Result of message: {0}", vm.Result);

                tcs.TrySetResult(vm.Result);
            });

            return(tcs.Task);
        }
コード例 #24
0
        private async Task OnEditSnapshotExecuteAsync(ISnapshot snapshot)
        {
            var modelValidation = snapshot as IValidatable;

            void OnSnapshotValidating(object sender, ValidationEventArgs e)
            {
                if (_snapshotManager.Snapshots.Any(x => x.Title.EqualsIgnoreCase(snapshot.Title) && x != snapshot))
                {
                    e.ValidationContext.Add(FieldValidationResult.CreateError("Title", _languageService.GetString("Snapshots_SnapshotWithCurrentTitleAlreadyExists")));
                }
            }

            if (modelValidation is not null)
            {
                modelValidation.Validating += OnSnapshotValidating;
            }

            if (await _uiVisualizerService.ShowDialogAsync <SnapshotViewModel>(snapshot) ?? false)
            {
                if (modelValidation is not null)
                {
                    modelValidation.Validating -= OnSnapshotValidating;
                }

                await _snapshotManager.SaveAsync();
            }
        }
コード例 #25
0
        public Task <bool?> ShowWizardAsync(IWizard wizard)
        {
            Argument.IsNotNull(() => wizard);

            Log.Debug("Showing wizard '{0}'", wizard.GetType().GetSafeFullName(false));

            return(_uiVisualizerService.ShowDialogAsync <WizardViewModel>(wizard));
        }
コード例 #26
0
 private void OnShowInstalledDialogExecute()
 {
     // Dispatch since we close the vm
     _dispatcherService.BeginInvoke(async() =>
     {
         await _uiVisualizerService.ShowDialogAsync <AppInstalledViewModel>();
         await CloseViewModelAsync(null);
     });
 }
コード例 #27
0
        private async Task OnChangeDbProviderAsync()
        {
            var dbProviderListViewModel = _typeFactory.CreateInstanceWithParametersAndAutoCompletion <DbConnectionProviderListViewModel>(DbProvider);

            if (await _uiVisualizerService.ShowDialogAsync(dbProviderListViewModel) ?? false)
            {
                DbProvider = dbProviderListViewModel.DbProvider;
            }
        }
コード例 #28
0
        private async Task OnAddOrderCommandExecuteAsync()
        {
            var order = new Order();

            var typeFactory = this.GetTypeFactory();
            var viewModel   = typeFactory.CreateInstanceWithParametersAndAutoCompletion <OrderAddWindowViewModel>(order);

            if (await _uiVisualizerService.ShowDialogAsync(viewModel) ?? false)
            {
                order.OrderDate = DateTime.Now;

                order.Save();
                Orders.Add(order);

                SelectedOrder = order;
                ShowProductsInOrderCommand.Execute();
            }
        }
コード例 #29
0
        private async Task OnBuildFilterExecuteAsync()
        {
            var vm = _viewModelFactory.CreateViewModel <SearchFilterBuilderViewModel>(null, null);

            if (await _uiVisualizerService.ShowDialogAsync(vm) ?? false)
            {
                Filter = vm.Filter;
            }
        }
コード例 #30
0
        /// <summary>
        /// Method to invoke when the AddTab command is executed.
        /// </summary>
        private async Task OnAddTabExecuteAsync()
        {
            var vm = new CreateTabWindowViewModel();

            if (await _uiVisualizerService.ShowDialogAsync(vm) ?? false)
            {
                _tabService.AddTab(vm.CloseWhenUnloaded);
            }
        }