Esempio n. 1
0
        private async void CreateExperimentAction()
        {
            var dialog = (BaseMetroDialog)Application.Current.Windows.OfType <MainWindow>().First().Resources["ExperimentDialog"];
            var experimentDialogViewModel = new ExperimentDialogViewModel
            {
                DialogCloseAction = async(vm) =>
                {
                    await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
                },
                DialogAddAction = async(vm) =>
                {
                    var newExperimentVm = new ExperimentViewModel();
                    newExperimentVm.InitFieldsFrom(vm);
                    ExperimentListViewModel.ExperimentTileCollection.Add(newExperimentVm);
                    EntityDataProvider <ExperimentEntity> .Instance.SaveManager.Map(newExperimentVm);

                    Logger.Info(StringResourceProvider.Instance[StringResourceProvider.Keys.Experiment_PLACE_WasAdded].Value, newExperimentVm.Name);
                    //todo save previous selected item data

                    ExperimentListViewModel.SelectedExperimentTile = null;
                    await Task.Delay(300);

                    ExperimentListViewModel.SelectedExperimentTile = newExperimentVm;
                    await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
                },
                Name             = "Experiment #" + DateTime.Now.ToString("yyyy MMMM dd HH:mm"),
                DateTime         = DateTime.Now,
                Category         = "Spectrum",
                WaveMax          = 720,
                WaveMin          = 430,
                ExperimentStatus = ExperimentStatus.Unknown,
                //DistanceRange = new ObservableCollection<double>() { 1.25, 1.5, 1.75, 2, 2.5 },
                DistanceRange = new ObservableCollection <double>()
                {
                    1.25, 1.375, 1.5, 1.625, 1.75, 1.875, 2, 2.25, 2.5
                },
                SpectrometerName = "LOTIS CMS-400",

                BaseDistance  = 1.25,
                DistanceToAdd = 2
            };

            //dialog.Content = experimentDialogViewModel;
            dialog.DataContext = experimentDialogViewModel;
            experimentDialogViewModel.PhysicModel = ParamsRetrieverManager.GetParamsRetrievers().FirstOrDefault();
            await MetroDialogCoordinator.ShowMetroDialogAsync(this, dialog);
        }
Esempio n. 2
0
        private async void SettingsAction()
        {
            var dialog            = (BaseMetroDialog)Application.Current.Windows.OfType <MainWindow>().First().Resources["SettingsDialog"];
            var settingsViewModel = new SettingsViewModel
            {
                DialogCloseAction = async(vm) =>
                {
                    await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
                },
                DialogSaveAction = async(vm) =>
                {
                    try
                    {
                        var lang = ((SettingsViewModel)vm).Language;
                        var path = ((SettingsViewModel)vm).SavePath;
                        if (lang != "En")
                        {
                            var xml = XElement.Load($"Language/{lang}.xml");
                            StringResourceProvider.Instance.PopulateStringResources(xml.Elements().ToDictionary(x => x.Attribute("ElementID")?.Value, x => x.Value));
                        }
                        else
                        {
                            StringResourceProvider.Instance.SetToDefaultStringResources();
                        }
                        //Logger.Info("");
                    }
                    catch (Exception e)
                    {
                        Logger.Error(e);
                    }
                    await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
                },
            };

            //dialog.Content = experimentDialogViewModel;
            dialog.DataContext = settingsViewModel;
            await MetroDialogCoordinator.ShowMetroDialogAsync(this, dialog);
        }
Esempio n. 3
0
        private async void SaveValues(string param)
        {
            if (Values == null || Values.Count < 1)
            {
                await MetroDialogCoordinator.ShowMessageAsync(MainWindowDataContext,
                                                              StringResourceProvider.Instance[StringResourceProvider.Keys.DataIsEmpty].Value,
                                                              StringResourceProvider.Instance[StringResourceProvider.Keys.PleaseRunSpectrometerAndTryToGetSpectralMeasurements].Value);

                return;
            }

            var previousState = IsRealTimeSpectrometerData;

            IsRealTimeSpectrometerData = false;
            var dataName  = StringResourceProvider.Instance[param].Value;
            var @override = false;
            var item      = new ExperimentEntityDataItemViewModel();

            switch (param)
            {
            case "CurrentL":
                if (CurrentDistance == 0)
                {
                    await MetroDialogCoordinator.ShowMessageAsync(MainWindowDataContext,
                                                                  StringResourceProvider.Instance[StringResourceProvider.Keys.DistanceDoesNotDefined].Value,
                                                                  StringResourceProvider.Instance[StringResourceProvider.Keys.PleaseMoveDetectorForSomeDistance].Value);

                    IsRealTimeSpectrometerData = previousState;
                    return;
                }
                @override = SavedData?.DataItems != null &&
                            SavedData.DataItems.Any(x => x.Distance == CurrentDistance);
                if (@override)
                {
                    item = SavedData.DataItems.First(x => x.Distance == CurrentDistance);
                }
                else
                {
                    item.Distance = CurrentDistance;
                    item.IsBase   = BaseDistance == item.Distance;
                }

                dataName = $"L = {item.Distance}{(item.IsBase ? $"({StringResourceProvider.Instance[StringResourceProvider.Keys.Base]})" : "")}";
                break;

            case "Noise":
                @override = SavedData?.DataItems != null &&
                            SavedData.DataItems.Any(x => x.IsNoise);
                if (@override)
                {
                    item = SavedData.DataItems.First(x => x.IsNoise);
                }
                else
                {
                    item.Distance = 0;    //CurrentDistance;
                    item.IsNoise  = true;
                }
                break;

            case "Normalize":
                @override = SavedData?.DataItems != null &&
                            SavedData.DataItems.Any(x => x.IsNormalize);
                if (@override)
                {
                    item = SavedData.DataItems.First(x => x.IsNormalize);
                }
                else
                {
                    item.Distance    = 0; //CurrentDistance;
                    item.IsNormalize = true;
                }


                break;

            default:
                throw new InvalidEnumArgumentException($"'{param}' is undefined value");
            }

            if (@override)
            {
                //MessageDialogResult result = await this.MetroDialogCoordinator.ShowMessageAsync(MainWindowDataContext, "Data already exist", $"Do you wont to replace {dataName}?", MessageDialogStyle.AffirmativeAndNegative);
                MessageDialogResult result = await MetroDialogCoordinator.ShowMessageAsync(MainWindowDataContext,
                                                                                           StringResourceProvider.Instance[StringResourceProvider.Keys.DataAlreadyExist].Value,
                                                                                           $"{StringResourceProvider.Instance[StringResourceProvider.Keys.DoYouWantToReplace].Value} '{dataName}'?",
                                                                                           MessageDialogStyle.AffirmativeAndNegative);

                if (result == MessageDialogResult.Negative)
                {
                    IsRealTimeSpectrometerData = previousState;
                    return;
                }
            }

            item.IntensityArray       = Values.Select(x => x.Intencity).ToArray();
            item.IsAppliedNormalizing = IsNormalize;
            item.IsNoiseRemoved       = IsNoiseRemove;

            if (!@override)
            {
                if (SavedData?.DataItems != null)
                {
                    SavedData.DataItems.Add(item);
                }
                else if (SavedData == null)
                {
                    SavedData = new ExperimentEntityDataViewModel()
                    {
                        WaveLengthArray = Values.Select(x => x.WaveLength).ToArray(),
                        DataItems       = new FullyObservableCollection <ExperimentEntityDataItemViewModel>()
                        {
                            item
                        }
                    };
                }
                else if (SavedData.DataItems == null)
                {
                    SavedData.WaveLengthArray = Values.Select(x => x.WaveLength).ToArray();
                    SavedData.DataItems       = new FullyObservableCollection <ExperimentEntityDataItemViewModel>()
                    {
                        item
                    };
                }
            }
            SetDataToHelper();
            NotifyPropertyChanged(nameof(IsShowSavedDataEnabled));
            IsRealTimeSpectrometerData = previousState;
        }