init

DTS Viewer/DTS.Viewer.Modules/DTS.Viewer.ViewerSettings/ViewModel/ViewerSettingsViewModel.cs

@@ -0,0 +1,184 @@
+using System;
+using System.ComponentModel;
+using System.Threading.Tasks;
+using System.Windows;
+using DTS.Common.Base;
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Events;
+using DTS.Common.Interactivity;
+using DTS.Common.Interface;
+using Prism.Events;
+using Prism.Regions;
+using Unity;
+
+namespace DTS.Viewer.ViewerSettings
+{
+    public class ViewerSettingsViewModel : BaseViewModel<IViewerSettingsViewModel>, IViewerSettingsViewModel
+    {
+        public IViewerSettingsView View { get; set; }
+        public IBaseViewModel Parent { get; set; }
+        private IEventAggregator _eventAggregator { get; set; }
+
+        private IUnityContainer _unityContainer { get; set; }
+        public InteractionRequest<Notification> NotificationRequest { get; private set; }
+        public new InteractionRequest<Confirmation> ConfirmationRequest { get; private set; }
+
+        /// <summary>
+        /// Creates a new instance of the TestSummaryViewListModel.
+        /// </summary>
+        /// <param name="view">The TestSummaryList View interface.</param>
+        /// <param name="regionManager">The logical placeholder defined within the application's UI (in the shell or within views) into which views are displayed.</param>
+        /// <param name="eventAggregator">The EventAggregator which allows different components to publish/subscribe to events without being coupled to each other.</param>
+        /// <param name="unityContainer">The unityContainer.</param>
+        public ViewerSettingsViewModel(IViewerSettingsView view, IRegionManager regionManager, IEventAggregator eventAggregator,
+            IUnityContainer unityContainer)
+            : base(regionManager, eventAggregator, unityContainer)
+        {
+            View = view;
+            View.DataContext = this;
+            NotificationRequest = new InteractionRequest<Notification>();
+            ConfirmationRequest = new InteractionRequest<Confirmation>();
+
+            _eventAggregator = eventAggregator;
+            _unityContainer = unityContainer;
+        }
+
+        #region Methods
+        public override void Initialize() { }
+
+        public override void Initialize(object parameter)
+        {
+            Parent = (IBaseViewModel)parameter;
+
+            Subscribe();
+        }
+
+        private void Subscribe()
+        {
+            //event aggregator subscriptions
+            _eventAggregator.GetEvent<CalibrationBehaviorSettingChangedEvent>().Subscribe(OnCalibrationBehaviorSettingChanged);
+            _eventAggregator.GetEvent<CalibrationBehaviorSettableInViewerChangedEvent>().Subscribe(OnCalibrationBehaviorSettableInViewerChanged);
+        }
+
+        private void OnCalibrationBehaviorSettableInViewerChanged(bool settable)
+        {
+            CalibrationBehaviorSettingVisibility = settable ? Visibility.Visible : Visibility.Collapsed;
+        }
+
+        private void OnCalibrationBehaviorSettingChanged(CalibrationBehaviors cb)
+        {
+            _calibrationBehaviorSetting = cb;
+            OnPropertyChanged("CalibrationBehaviorSetting");
+        }
+
+        public void PublishChanges()
+        {
+        }
+
+        #endregion
+
+        #region Properties
+        ///<summary>
+        ///Occurs when a property value changes.
+        ///</summary>
+        public new event PropertyChangedEventHandler PropertyChanged;
+        private new void OnPropertyChanged(string propertyName)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            if (propertyName.EndsWith("Visibility") && propertyName != "OverallSettingsVisibility")
+            {
+                OnPropertyChanged("OverallSettingsVisibility");
+            }
+        }
+
+        /// <summary>
+        /// Gets the HeaderInfo.
+        /// </summary>
+        public string HeaderInfo => "SettingsRegion";
+
+        private bool _isBusy = false;
+        public new bool IsBusy
+        {
+            get => _isBusy;
+            set { _isBusy = value; OnPropertyChanged("IsBusy"); }
+        }
+
+        private bool _isDirty;
+        public new bool IsDirty
+        {
+            get => _isDirty;
+            set => _isDirty = value;
+        }
+
+        private bool _isNavigationIncluded;
+        public new bool IsNavigationIncluded
+        {
+            get => _isNavigationIncluded;
+            set => _isNavigationIncluded = value;
+        }
+
+        private Visibility _calibrationBehaviorSettingVisibility = Visibility.Visible;
+
+        public Visibility CalibrationBehaviorSettingVisibility
+        {
+            get => _calibrationBehaviorSettingVisibility;
+            set
+            {
+                _calibrationBehaviorSettingVisibility = value;
+                OnPropertyChanged("CalibrationBehaviorSettingVisibility");
+                _eventAggregator.GetEvent<ViewerSettingsVisibilityChangedEvent>().Publish(OverallSettingsVisibility);
+            }
+        }
+
+        public Visibility OverallSettingsVisibility => (CalibrationBehaviorSettingVisibility == Visibility.Visible) ? Visibility.Visible : Visibility.Collapsed;
+
+        #endregion
+
+        private DisplayedCalibrationBehavior[] _availableCalibrationBehaviors = null;
+
+        private readonly DisplayedCalibrationBehavior _linearIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.LinearIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_LinearIfAvailable };
+        private readonly DisplayedCalibrationBehavior _nonLinearIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.NonLinearIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_NonLinearIfAvailable };
+        private readonly DisplayedCalibrationBehavior _useBothIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.UseBothIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_UseBothIfAvailable };
+        private readonly object MyLock = new object();
+        public DisplayedCalibrationBehavior[] AvailableCalibrationBehaviors
+        {
+            get
+            {
+                lock (MyLock)
+                {
+                    if (null == _availableCalibrationBehaviors)
+                    {
+                        _availableCalibrationBehaviors = new[] { _linearIfAvail, _nonLinearIfAvail, _useBothIfAvail };
+                    }
+                    return _availableCalibrationBehaviors;
+                }
+            }
+        }
+
+        private CalibrationBehaviors _calibrationBehaviorSetting = CalibrationBehaviors.NonLinearIfAvailable;
+        public DisplayedCalibrationBehavior CalibrationBehaviorSetting
+        {
+            get
+            {
+                foreach (DisplayedCalibrationBehavior dcb in AvailableCalibrationBehaviors)
+                {
+                    if (dcb.CalibrationBehavior == _calibrationBehaviorSetting)
+                    {
+                        return dcb;
+                    }
+                }
+                return null;
+            }
+            set
+            {
+                if (value.CalibrationBehavior != _calibrationBehaviorSetting)
+                {
+                    _calibrationBehaviorSetting = value.CalibrationBehavior;
+                    _eventAggregator.GetEvent<CalibrationBehaviorSettingChangedEvent>().Publish(value.CalibrationBehavior);
+                }
+                OnPropertyChanged("CalibrationBehaviorSetting");
+            }
+        }
+    }
+}